graph.cpp

大家好！这是一个网络游戏源码

#include "runner_game.h"
#include "graph.h"

int		g_iViewAtWorldX = 0;
int		g_iViewAtWorldY = 0;

DWORD GetSurfaceWidth(LPDIRECTDRAWSURFACE7 pSurface)
{
   if(pSurface==NULL)
   {
      return 0;
   }
   DDSURFACEDESC2 dc;
   INIT_STRUCT(dc);
   pSurface->GetSurfaceDesc(&dc);
   return dc.dwWidth;
}

DWORD GetSurfaceHeight(LPDIRECTDRAWSURFACE7 pSurface)
{
   if(pSurface==NULL)
   {
      return 0;
   }
   DDSURFACEDESC2 dc;
   INIT_STRUCT(dc);
   pSurface->GetSurfaceDesc(&dc);
   return dc.dwHeight;
}

VOID GetSurfaceSize(LPDIRECTDRAWSURFACE7 pSurface , LPDWORD pdwWidth , LPDWORD pdwHeight)
{
    if(pSurface==NULL)
	{
		if(pdwWidth!=NULL)  *pdwWidth  = 0;
		if(pdwHeight!=NULL) *pdwHeight = 0;
		return ;
	}
	DDSURFACEDESC2 dc;
    INIT_STRUCT(dc);
	pSurface->GetSurfaceDesc(&dc);
	if(pdwWidth!=NULL)  *pdwWidth  = dc.dwWidth;
	if(pdwHeight!=NULL) *pdwHeight = dc.dwHeight;
}
   


LPDIRECTDRAWSURFACE7 GetSurfaceFromBmpFile24(char *strFileName)
{
   	if(g_pDD==NULL)
	{
	   MSG_STR("g_pDDraw is NULL!");
	   return NULL;
	}
	FILE *fp;
	fp = fopen(strFileName , "rb");
	if(fp==NULL)
	{
	   MSG_STR("Read 24Bit Bitmap Error!");
	   return NULL;
	}
	fseek(fp , 0 , SEEK_END);
	DWORD dwFileSize = ftell(fp);
	fseek(fp , 0 , SEEK_SET);
	
	BITMAPFILEHEADER bmfheader;
	
	fread(&bmfheader , sizeof(BITMAPFILEHEADER) , 1 , fp);
	
	DWORD dwDIBLength = dwFileSize - sizeof(BITMAPFILEHEADER);
	
	LPBYTE pbImageData;GetMemory(pbImageData , BYTE , dwDIBLength);
	
	fread(pbImageData , dwDIBLength , 1 , fp);
	
	fclose(fp);
	
	BITMAPINFOHEADER &bmiheader=*(LPBITMAPINFOHEADER)pbImageData ; 
	BITMAPINFO &bminfo= *(LPBITMAPINFO)pbImageData ; 
	
	int ncolors =  bmiheader.biClrUsed ? bmiheader.biClrUsed : 1 << bmiheader.biBitCount; 
	LPVOID pDIBBits; 
	if( bminfo.bmiHeader.biBitCount> 8 )
	{
		pDIBBits = (LPVOID)( (LPDWORD)(bminfo.bmiColors + bminfo.bmiHeader.biClrUsed) + 0);
	}
	else
	{
		pDIBBits = (LPVOID)(bminfo.bmiColors + ncolors);
	}
    DWORD w = bmiheader.biWidth;
	DWORD h = bmiheader.biHeight;
    
	LPBYTE pBits = (LPBYTE)pDIBBits;
	
	
	DDSURFACEDESC2          ddsd;
    INIT_STRUCT(ddsd);
    
	LPDIRECTDRAWSURFACE7	pSurface = CreateSurface(w , h , SURFACE_TYPE_NORMAL);
    if (pSurface==NULL)
	{
	    MSG_STR("Create Surface error!");
	    FreeMemory(pbImageData);
        return NULL;
	}
    
	pSurface->Lock(NULL , &ddsd , DDLOCK_WRITEONLY , NULL);
	
	LPWORD pwSurfaceData = (LPWORD)ddsd.lpSurface;
	pwSurfaceData+=(h - 1) * w;
	
	DWORD dwLineSize = w * 3;
	
	int numREDbits   = 5;
	int numGREENbits = 6;
	int numBLUEbits  = 5;
	
	int loREDbit   = 11;
	int loGREENbit = 5;
	int loBLUEbit  = 0;

	/*
	if(color_format==D3DFMT_X1R5G5B5)
	{
	   numREDbits   = 5;
	   numGREENbits = 5;
	   numBLUEbits  = 5;
	   
	   loREDbit     = 10;
	   loGREENbit   = 5;
	   loBLUEbit    = 0;
	}*/
	
	float REDdiv   = (float)256/(float)pow( 2, numREDbits   );
	float GREENdiv = (float)256/(float)pow( 2, numGREENbits );
	float BLUEdiv  = (float)256/(float)pow( 2, numBLUEbits  );

	
	for(DWORD y = 0 ; y < h ; y++)
	{
	   RGBTRIPLE* triple=(RGBTRIPLE*)pBits;
	   for(DWORD x = 0 ; x < w ; x++)
	   {
	      	float rf=(float)triple->rgbtRed/REDdiv;
			float gf=(float)triple->rgbtGreen/GREENdiv;
			float bf=(float)triple->rgbtBlue/BLUEdiv;

			WORD r=(WORD)((WORD)rf<<loREDbit);
			WORD g=(WORD)((WORD)gf<<loGREENbit);
			WORD b=(WORD)((WORD)bf<<loBLUEbit);

			*(pwSurfaceData + x) = r|g|b;
			triple++;
	  }
	  pwSurfaceData-=w;
	  pBits+=dwLineSize;
	}
	pSurface->Unlock(NULL);
	
	FreeMemory(pbImageData);
	
	return pSurface;
}


void MSG_STR(char *str)
{
   MessageBox(NULL , str , "" , 0);
}

void MSG_NUM(long n)
{
   char mm[8];
   ltoa(n , mm , 10);
   MessageBox(NULL , mm , "num = " , 0);
}

VOID OutputText( int x , int y , TCHAR* str , DWORD color)
{
    int StrSize = strlen(str);
	int iBorderX = StrSize * 8 * -1;
	int iBorderY = -8;
	if(x < iBorderX || y < iBorderY || x > g_iViewWidth || y > g_iViewHeight) return;
	HDC hDC;
	if( g_pddsRenderTarget )
    {
        if( SUCCEEDED( g_pddsRenderTarget->GetDC(&hDC) ) )
        {
            SetTextColor( hDC, color );
            SetBkMode( hDC, TRANSPARENT );
            ExtTextOut( hDC, x, y, 0, NULL , str , StrSize , NULL );
            g_pddsRenderTarget->ReleaseDC(hDC);
        }
    }
}

LPDIRECTDRAWSURFACE7 CreateSurface(int iWidth , int iHeight , int iSurfaceType)
{
 	DDSURFACEDESC2          ddsd;
    LPDIRECTDRAWSURFACE7	pSurface = NULL;
    INIT_STRUCT(ddsd);
    
	ddsd.dwFlags		 = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
    ddsd.dwWidth         = iWidth;
    ddsd.dwHeight        = iHeight;
    
	if(iSurfaceType==SURFACE_TYPE_TEXTURE)
	{
		ddsd.ddsCaps.dwCaps  = DDSCAPS_TEXTURE|DDSCAPS_VIDEOMEMORY;
	}
	if(iSurfaceType==SURFACE_TYPE_NORMAL)
	{
	    ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN|DDSCAPS_VIDEOMEMORY;
	}
    
	HRESULT r = g_pDD->CreateSurface(&ddsd , &pSurface , NULL);
	if(r!=DD_OK)
	{
		MSG_STR("Create Surface error!");
	    return NULL;
	}
    return pSurface;
}

DWORD RGB2DWORD(BYTE red , BYTE green , BYTE blue)
{
	float FractionRed   = (float)red/255.0f;
	float FractionGreen = (float)green/255.0f;
	float FractionBlue  = (float)blue/255.0f;
	
	DDPIXELFORMAT ddpf;
	ddpf.dwSize=sizeof(ddpf); 
	g_pddsRenderTarget->GetPixelFormat(&ddpf);
	
	
	DWORD r = ((DWORD)((float)ddpf.dwRBitMask * FractionRed  )) & ddpf.dwRBitMask;
	DWORD g = ((DWORD)((float)ddpf.dwGBitMask * FractionGreen)) & ddpf.dwGBitMask;
	DWORD b = ((DWORD)((float)ddpf.dwBBitMask * FractionBlue )) & ddpf.dwBBitMask;
	 
	return (r + g + b);
}


DWORD COLOR_RED;
DWORD COLOR_BLUE;
DWORD COLOR_GREEN;
DWORD COLOR_YELLOW;
DWORD COLOR_GRAY;
DWORD COLOR_WHITE;
DWORD COLOR_BLACK;
DWORD COLOR_DARK;

VOID	InitGeneralColor()
{
	COLOR_RED    = RGB2DWORD(255,0,0);
    COLOR_BLUE   = RGB2DWORD(0,0,255);
    COLOR_GREEN  = RGB2DWORD(0,255,0);
    COLOR_YELLOW = RGB2DWORD(230,220,4);
    COLOR_GRAY   = RGB2DWORD(128,128,128);	
    COLOR_WHITE  = RGB2DWORD(255,255,255);
    COLOR_BLACK  = RGB2DWORD(48,48,48);
	COLOR_DARK   = RGB2DWORD(1,1,1);
}

VOID	SaveSurface16(LPDIRECTDRAWSURFACE7 pSurface , char *strFileName)
{
	if(pSurface==NULL) return;
	
	DDSURFACEDESC2          ddsd;
    INIT_STRUCT(ddsd);
    pSurface->Lock(NULL , &ddsd , DDLOCK_READONLY , NULL);		
	LPWORD pwSurfaceData = (LPWORD)ddsd.lpSurface;
	int w		= ddsd.dwWidth;
	int h		= ddsd.dwHeight;
	int Pitch	= (int)ddsd.lPitch / 2;
	FILE *fp = fopen(strFileName , "wb");
	
	fwrite((LPWORD)&w , 2 , 1 , fp);
	fwrite((LPWORD)&h , 2 , 1 , fp);

	for(int y = 0 ; y < h ; y++)
	{
	    fwrite(pwSurfaceData , w * 2 , 1 , fp);
		pwSurfaceData+=Pitch;
	}
	fclose(fp);
	pSurface->Unlock(0);
}


LPDIRECTDRAWSURFACE7	GetSurfaceFromSurFile16(char *strFileName)
{
	FILE *fp = fopen(strFileName , "rb");
	if(fp==NULL)
	{
	    MSG_STR("open sur file failed!");
	    return NULL;
	}
	WORD w , h;
	fread(&w , 2 , 1 , fp);
	fread(&h , 2 , 1 , fp);
	
	LPDIRECTDRAWSURFACE7 pSurface = CreateSurface(w , h , SURFACE_TYPE_NORMAL);
	if(pSurface==NULL)
	{
		fclose(fp);
		MSG_STR("Create Surface Failed!");
		return NULL;
	}
	
	DDSURFACEDESC2          ddsd;
    INIT_STRUCT(ddsd);
    pSurface->Lock(NULL , &ddsd , DDLOCK_WRITEONLY , NULL);		
	LPWORD pwSurfaceData = (LPWORD)ddsd.lpSurface;
	int Pitch	= (int)ddsd.lPitch / 2;
	
	for(int y = 0 ; y < h ; y++)
	{
	    fread(pwSurfaceData , w * 2 , 1 , fp);
		pwSurfaceData+=Pitch;
	}
	
	pSurface->Unlock(0);
	fclose(fp);
	return pSurface;
}


LPDIRECTDRAWSURFACE7	CreateSurfaceFromFileList()
{
	LPDIRECTDRAWSURFACE7	pChaSurface1 = CreateSurface(64 * 8 , 96 * 8	, SURFACE_TYPE_NORMAL);
	
	LPDIRECTDRAWSURFACE7	pTempSurface;
	char *FileNameList[255];
	char strFileName[255];
	int OffX = 0;
	int OffY = 0;
	for(int i = 0 ; i < 8 ; i++)
	{
		char mm[4];
		char strPath[255];
		strcpy(strPath , "man008/walk/dire_0");
		strcat(strPath , itoa(i , mm , 10));
		GetDirFileName(FileNameList , strPath , 0);
		int n = 0;
		DWORD w , h;
		OffX = 0;
		while(FileNameList[n]!=NULL)
		{
			if(strstr(FileNameList[n] , ".bmp")!=NULL)
			{
				//MSG_STR(FileNameList[n]);
				strcpy(strFileName , strPath);
				strcat(strFileName , "/");
				strcat(strFileName , FileNameList[n]);
			
				pTempSurface = GetSurfaceFromBmpFile24(strFileName);
				GetSurfaceSize(pTempSurface , &w , &h);
				RECT rc1 ,	rc2;
				rc1.left	= 0	; 
				rc1.right	= w	; 
				rc1.top		= 0	;
				rc1.bottom	= h	;

				rc2.left    = OffX;
				rc2.right   = OffX + w;
				rc2.top     = OffY;
				rc2.bottom	= OffY + h;
				pChaSurface1->Blt(&rc2 , pTempSurface , &rc1 , DDBLT_WAIT , NULL);
				SAFE_RELEASE(pTempSurface);
			
				OffX+=w;
			}
			FreeMemory(FileNameList[n]);
			n++;
		}
		OffY+=96;
	}
	
	SaveSurface16(pChaSurface1 , "man008_walk.sur");
	SAFE_RELEASE(pChaSurface1);
	return NULL;
}

VOID	BltSurface(int DrawX , int DrawY , LPDIRECTDRAWSURFACE7 pdds , BOOL boColorKey)
{
	
	if(pdds==NULL) return;
	DWORD w , h;
	GetSurfaceSize(pdds , &w , &h);
	RECT	rcDest;
    rcDest.left		= DrawX;
	rcDest.top		= DrawY;
    rcDest.right	= rcDest.left + w;
	rcDest.bottom	= rcDest.top  + h;

	RECT	rcScr;
	rcScr.left		= 0;
	rcScr.top		= 0;
	rcScr.right		= g_iViewWidth;
	rcScr.bottom	= g_iViewHeight;

	RECT rcInter;
	if(IntersectRect(&rcInter , &rcDest , &rcScr))
	{
		//将rcInter转化为源图坐标
		RECT	rc1;
		rc1.left	= rcInter.left - DrawX;
		rc1.top		= rcInter.top  - DrawY;
		rc1.right	= rc1.left + rcInter.right  - rcInter.left;
		rc1.bottom	= rc1.top  + rcInter.bottom - rcInter.top;
		
		if(boColorKey)	g_pddsRenderTarget->Blt(&rcInter , pdds , &rc1 , DDBLT_WAIT|DDBLT_KEYSRC , NULL);
		else            g_pddsRenderTarget->Blt(&rcInter , pdds , &rc1 , DDBLT_WAIT , NULL); 
	}
}


VOID    BltSurfaceRect(int DrawX , int DrawY , LPDIRECTDRAWSURFACE7 pdds , RECT rcSrc , BOOL boColorKey)
{
	if(pdds==NULL) return;
	RECT	rcDest;
    rcDest.left		= DrawX;
	rcDest.top		= DrawY;
    rcDest.right	= DrawX + rcSrc.right - rcSrc.left;
	rcDest.bottom	= DrawY + rcSrc.bottom - rcSrc.top;

	RECT	rcScr;
	rcScr.left		= 0;
	rcScr.top		= 0;
	rcScr.right		= g_iViewWidth;
	rcScr.bottom	= g_iViewHeight;    

	RECT rcInter;
	if(IntersectRect(&rcInter , &rcDest , &rcScr))
	{
		//MSG_NUM(rcInter.left);
		
		//将rcInter转化为源图坐标
		
		RECT	rc1;
		rc1.left	= rcInter.left - DrawX;