dxlib.cpp

一个VC游戏源码,带运行程序,供大家学习之用

#include"DXLIB.h"

LPDIRECTDRAW7 lpdd;
LPDIRECTDRAWSURFACE7 lpsurmain;
LPDIRECTDRAWSURFACE7 lpsurback;
DDSURFACEDESC2 ddsdmain;
DDSURFACEDESC2 ddsdback;

RECT rectwnd;
UINT topadjust;
UINT bottomadjust;
UINT borderadjust;

RECT rectmain;
RECT rectback;

UINT clientwidth;
UINT clientheight;

DWORD bitcount;

HRESULT InitDirectDraw(HWND hwnd,UINT width,UINT height)
{
	clientwidth=width;
	clientheight=height;
	DD_Call(DirectDrawCreateEx(NULL,(void**)&lpdd,IID_IDirectDraw7,NULL));
	DD_Call(lpdd->SetCooperativeLevel(hwnd,DDSCL_NORMAL));

	memset(&ddsdmain,0,sizeof(DDSURFACEDESC2));
	ddsdmain.dwSize=sizeof(DDSURFACEDESC2);
	ddsdmain.dwFlags=DDSD_CAPS;
	ddsdmain.ddsCaps.dwCaps=DDSCAPS_PRIMARYSURFACE;
	DD_Call(lpdd->CreateSurface(&ddsdmain,&lpsurmain,NULL));

	LPDIRECTDRAWCLIPPER lpclip;
	DD_Call(lpdd->CreateClipper(NULL,&lpclip,NULL));
	DD_Call(lpclip->SetHWnd(NULL,hwnd));
	DD_Call(lpsurmain->SetClipper(lpclip));
	SafeRelease(lpclip);

	CreateSurface(width,height,&lpsurback);
	SetRect(&rectback,0,0,width,height);

	SetRect(&rectwnd,0,0,width,height);
	AdjustWindowRectEx(&rectwnd,GetWindowStyle(hwnd),GetMenu(hwnd)!=NULL,GetWindowExStyle(hwnd));
	MoveWindow(hwnd,20,20,rectwnd.right-rectwnd.left,rectwnd.bottom-rectwnd.top,TRUE);
	topadjust=0-rectwnd.top;
	bottomadjust=rectwnd.bottom-height;
	borderadjust=0-rectwnd.left;

	DDSURFACEDESC2 ddsd;
	memset(&ddsd,0,sizeof(ddsd));
	ddsd.dwSize=sizeof(ddsd);
	DD_Call(lpdd->GetDisplayMode(&ddsd));
	if((ddsd.ddpfPixelFormat.dwFlags&DDPF_RGB)==0)
	{
		MessageBox(hwnd,__T("该游戏不支持当前显示设置,请设置16位以上色彩模式"),__T("错误"),MB_OK|MB_ICONWARNING);
		return DD_FALSE;
	}
	bitcount=ddsd.ddpfPixelFormat.dwRGBBitCount;
	if(bitcount!=32)
	{
		//MessageBox(hwnd,__T("该游戏仅支持32位色彩模式"),__T("错误"),MB_OK|MB_ICONWARNING);
		//return DD_FALSE;
	}

	return DD_OK;
}

HRESULT CreateSurface(UINT width,UINT height,LPDIRECTDRAWSURFACE7* lplpsur)
{
	SafeRelease((*lplpsur)); 

	DDSURFACEDESC2 ddsd;
	memset(&ddsd,0,sizeof(ddsd));
	ddsd.dwSize=sizeof(ddsd);
	ddsd.dwFlags=DDSD_CAPS|DDSD_WIDTH|DDSD_HEIGHT|DDSD_CKSRCBLT;
	ddsd.ddsCaps.dwCaps=DDSCAPS_OFFSCREENPLAIN|DDSCAPS_SYSTEMMEMORY;
	ddsd.dwWidth=width;
	ddsd.dwHeight=height;
	ddsd.ddckCKSrcBlt.dwColorSpaceLowValue=0;
	ddsd.ddckCKSrcBlt.dwColorSpaceHighValue=0;
	DD_Call(lpdd->CreateSurface(&ddsd,&(*lplpsur),NULL));

	LPDIRECTDRAWCLIPPER lpclip;
	RECT rect={0,0,width,height};
	LPRGNDATA lprgn=(LPRGNDATA)malloc(sizeof(RECT)+sizeof(RGNDATAHEADER));
	memcpy(lprgn->Buffer,&rect,sizeof(RECT));
	lprgn->rdh.dwSize=sizeof(RGNDATAHEADER);
	lprgn->rdh.iType=RDH_RECTANGLES;
	lprgn->rdh.nCount=1;
	lprgn->rdh.nRgnSize=sizeof(RECT);
	lprgn->rdh.rcBound=rect;
	DD_Call(lpdd->CreateClipper(NULL,&lpclip,NULL));
	if(FAILED(lpclip->SetClipList(lprgn,NULL)))
	{
		free(lprgn);
		return DD_FALSE;
	}
	free(lprgn);
	if(FAILED((*lplpsur)->SetClipper(lpclip)))
	{
		SafeRelease(lpclip);
		return DD_FALSE;
	}
	SafeRelease(lpclip);
	return DD_OK;
}

HRESULT CreateGraph(GRAPH* lpgraph,double x,double y,UINT width,UINT height,UINT type)
{
	CreateSurface(width,height,&lpgraph->lpsur);
	lpgraph->x=x;
	lpgraph->y=y;
	lpgraph->xctrl=0;
	lpgraph->yctrl=0;
	SetRectPos(lpgraph->srcrect,0,0,width,height);
	SetRectPos(lpgraph->destrect,(int)x,(int)y,width,height);
	lpgraph->visible=1;
	lpgraph->type=type;
	return DD_OK;
}

int ReleaseDirectDraw()
{
	SafeRelease(lpdd);
	SafeRelease(lpsurmain);
	SafeRelease(lpsurback);
	return 1;
}

HRESULT CleanScreen(COLORREF color)
{
	DDBLTFX bltfx;
	memset(&bltfx,0,sizeof(DDBLTFX));
	bltfx.dwSize=sizeof(DDBLTFX);
	bltfx.dwFillColor=color;
	DD_Call(lpsurback->Blt(&rectback,NULL,NULL,DDBLT_WAIT|DDBLT_COLORFILL,&bltfx));
	return DD_OK;
}

HRESULT BackToFront(HWND hwnd)
{
	GetWindowRect(hwnd,&rectmain);
	rectmain.top+=topadjust;
	rectmain.bottom-=bottomadjust;
	rectmain.left+=borderadjust;
	rectmain.right-=borderadjust;
	DD_Call(lpsurmain->Blt(&rectmain,lpsurback,&rectback,DDBLT_WAIT,NULL));
	return DD_OK;
}

HRESULT DrawString(INT x,INT y,TCHAR* string,COLORREF color)
{
	HDC hdc;
	DD_Call(lpsurback->GetDC(&hdc));
	SetBkMode(hdc,TRANSPARENT);
	SetTextColor(hdc,color);
	TextOut(hdc,x,y,string,(int)_tcslen(string));
	DD_Call(lpsurback->ReleaseDC(hdc));
	return DD_OK;
}

int LoadBitmapFile(BITMAPFILE* lpbitmap,TCHAR* filename)
{
	HFILE hfile;
	OFSTRUCT fileinfo;
	if((hfile=OpenFile(filename,&fileinfo,OF_READ))==HFILE_ERROR)return 0;
	_lread(hfile,&lpbitmap->bmfheader,sizeof(BITMAPFILEHEADER));
	if(lpbitmap->bmfheader.bfType!=0x4d42)
	{
		_lclose(hfile);
		return 0;
	}
	_lread(hfile,&lpbitmap->bmiheader,sizeof(BITMAPINFOHEADER));
	if(lpbitmap->bmiheader.biBitCount==8)
	{
		_lread(hfile,lpbitmap->palette,sizeof(PALETTEENTRY)*MAXPALETTEENTRYS);
		int i,tempcolor;
		for(i=0;i<MAXPALETTEENTRYS;i++)
		{
			tempcolor=lpbitmap->palette[i].peBlue;
			lpbitmap->palette[i].peBlue=lpbitmap->palette[i].peRed;
			lpbitmap->palette[i].peRed=tempcolor;
			lpbitmap->palette[i].peFlags=PC_NOCOLLAPSE;
		}
	}
	_lseek(hfile,lpbitmap->bmiheader.biSizeImage,SEEK_END);
	if(lpbitmap->byte)free(lpbitmap->byte);
	if(!(lpbitmap->byte=(BYTE*)malloc(lpbitmap->bmiheader.biSizeImage)))
	{
		_lclose(hfile);
		return 0;
	}
	_lread(hfile,lpbitmap->byte,lpbitmap->bmiheader.biSizeImage);
	_lclose(hfile);


		//翻转位图
	if(abs(lpbitmap->bmiheader.biHeight)==lpbitmap->bmiheader.biHeight)
	{
		UCHAR* tmpbuf=(UCHAR*)malloc(lpbitmap->bmiheader.biSizeImage);
		memcpy(tmpbuf,lpbitmap->byte,lpbitmap->bmiheader.biSizeImage);
		int tmpwid=lpbitmap->bmiheader.biSizeImage/lpbitmap->bmiheader.biHeight;
		int bmpwid=lpbitmap->bmiheader.biWidth*(lpbitmap->bmiheader.biBitCount/8);
		int i;
		for(i=0;i<lpbitmap->bmiheader.biHeight;i++)
		{
			memcpy(
				&lpbitmap->byte[(lpbitmap->bmiheader.biHeight-1-i)*bmpwid],
				&tmpbuf[i*tmpwid],
				bmpwid
				);
		}
		free(tmpbuf);
	}


	return 1;
}

int ReleaseBitmapFile(BITMAPFILE* lpbitmap)
{
	if(lpbitmap->byte)free(lpbitmap->byte);
	return 1;
}

HRESULT CreateGraphFromBitmap(GRAPH* lpgraph,double x,double y,BITMAPFILE* lpbitmap,UINT type)
{
	CreateGraph(lpgraph,x,y,lpbitmap->bmiheader.biWidth,lpbitmap->bmiheader.biHeight,type);
	DDSURFACEDESC2 ddsd;
	memset(&ddsd,0,sizeof(DDSURFACEDESC2));
	ddsd.dwSize=sizeof(DDSURFACEDESC2);
	DD_Call(lpgraph->lpsur->Lock(NULL,&ddsd,DDLOCK_WAIT|DDLOCK_SURFACEMEMORYPTR,NULL));
	BYTE* bmpbuf=(BYTE*)lpbitmap->byte;
	BYTE* surbuf=(BYTE*)ddsd.lpSurface;
	LONG lpitch=ddsd.lPitch;
	BYTE r,g,b;
	WORD pix16;
	int ix,iy,bmpcur,surcur;
	for(iy=0;iy<lpbitmap->bmiheader.biHeight;iy++)
	{
		for(ix=0;ix<lpbitmap->bmiheader.biWidth;ix++)
		{
			bmpcur=(iy*lpbitmap->bmiheader.biWidth+ix)*3;
			switch(bitcount)
			{
			case 15:
				surcur=(iy*lpitch+(ix<<1));
				r=bmpbuf[bmpcur+2]>>3;
				g=bmpbuf[bmpcur+1]>>3;
				b=bmpbuf[bmpcur]>>3;
				pix16=(r<<10)|(g<<5)|(b);
				surbuf[surcur]=(BYTE)(pix16&0xFF);
				surbuf[surcur+1]=(BYTE)(pix16>>8);
				break;
			case 16:
				surcur=(iy*lpitch+(ix<<1));
				r=bmpbuf[bmpcur+2]>>3;
				g=bmpbuf[bmpcur+1]>>2;
				b=bmpbuf[bmpcur]>>3;
				pix16=(r<<11)|(g<<5)|(b);
				surbuf[surcur]=(BYTE)(pix16&0xFF);
				surbuf[surcur+1]=(BYTE)(pix16>>8);
				break;
			case 24:
				surcur=(iy*lpitch+(ix*3));
				surbuf[surcur]=bmpbuf[bmpcur];
				surbuf[surcur+1]=bmpbuf[bmpcur+1];
				surbuf[surcur+2]=bmpbuf[bmpcur+2];
				break;
			case 32:
				surcur=iy*lpitch+(ix<<2);
				surbuf[surcur]=bmpbuf[bmpcur];
				surbuf[surcur+1]=bmpbuf[bmpcur+1];
				surbuf[surcur+2]=bmpbuf[bmpcur+2];
				break;
			default:break;
			}
		}
	}
	DD_Call(lpgraph->lpsur->Unlock(NULL));

	return DD_OK;
}

HRESULT GraphToBack(GRAPH* lpgraph,COLORREF color)
{
	if(color>0)
	{
		DDCOLORKEY ckey;
		ckey.dwColorSpaceHighValue=color;
		ckey.dwColorSpaceLowValue=color;
		DD_Call(lpgraph->lpsur->SetColorKey(DDCKEY_SRCBLT,&ckey));
	}
	DD_Call(lpsurback->Blt(&lpgraph->destrect,lpgraph->lpsur,&lpgraph->srcrect,DDBLT_WAIT|DDBLT_KEYSRC,NULL));
	return DD_OK;
}

HRESULT GraphToGraph(GRAPH* lpdestgraph,GRAPH* lpsrcgraph)
{
	DD_Call(lpdestgraph->lpsur->Blt(&lpdestgraph->srcrect,lpsrcgraph->lpsur,&lpdestgraph->cliprect,DDBLT_WAIT,NULL));
	return DD_OK;
}

int SetGraphPos(GRAPH* lpgraph,double x,double y)
{
	RECT rect=lpgraph->srcrect;
	lpgraph->x=x;
	lpgraph->y=y;
	SetRect(&lpgraph->destrect,(int)x,(int)y,(int)x+rect.right-rect.left,(int)y+rect.bottom-rect.top);
	return 1;
}

int SetGraphCtrl(GRAPH* lpgraph,int xctrl,int yctrl)
{
	lpgraph->xctrl=xctrl;
	lpgraph->yctrl=yctrl;
	return 1;