ddutil.cpp

一款不错的射击类游戏

				pwSur += ((lPriPitch>>1) * (head.Height - 1));
				WORD *pwTemp = pwSur;
				while(fread(&dwColor,sizeof(DWORD),1, file))
				{
					nTotal++;
					//A R G B
					dwAttribute = ((dwColor & 0xff000000)>>24) & 0xff;
					fAlpha = (float)dwAttribute/255;
					if(fAlpha == 0) dwTemp = 0;
					else
					{
						dwTemp = (DWORD)(((dwColor & 0xff0000)>>8)*fAlpha + 0x8800*(1-fAlpha)) & 0xf800;
						dwTemp += (DWORD)(((dwColor & 0xff00)>>5)*fAlpha + 0x3e0*(1-fAlpha)) & 0x7e0;
						dwTemp += (DWORD)(((dwColor & 0xff)>>3)*fAlpha + 0x18*(1-fAlpha)) & 0x1F;
					}
					*pwSur = dwTemp;
					pwSur++;

					if(nTotal >= head.Width)
					{
						if(++nHang == head.Height) break;
						nTotal = 0;
						pwTemp -= head.Width;
						pwSur = pwTemp;
					}
				}
			}
			(*ppSurface)->GetDDrawSurface()->Unlock(NULL);
			(*ppSurface)->SetColorKey(0);
		}
		fclose(file);
	}
    return S_OK;
}

//////////////////////////////
//TEst
//////////////////////////////
HRESULT CDisplay::CreateAlphaSurfaceFromTGA(LPALPHASURFACE* ppAlphaSurface,const TCHAR* strTGA)
{
    HRESULT        hr;
    DDSURFACEDESC2 ddsd;
	TgaHead		   head;
	long lPriPitch = 0;
	BYTE * pAlpha = NULL;
	
    if( m_pDD == NULL || strTGA == NULL ) 
        return E_INVALIDARG;
    *ppAlphaSurface = NULL;
	

	//Open TGA 
	FILE* file = NULL;
	if(file = _tfopen(strTGA, _T("rb")))
	{
		fread(&head, sizeof(TgaHead), 1, file);
	
	    //  Try to load the bitmap as a resource, if that fails, try it as a file
		// 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 | DDSCAPS_SYSTEMMEMORY;
		ddsd.dwWidth = head.Width;
		ddsd.dwHeight = head.Height;

		(*ppAlphaSurface) = new AlphaSurface;
		(*ppAlphaSurface)->lpSurface = new CSurface();
		if( FAILED( hr = (*ppAlphaSurface)->lpSurface->Create( m_pDD, &ddsd ) ) )
		{
			delete (*ppAlphaSurface)->lpSurface;
			delete (*ppAlphaSurface);
			return hr;
		}
		(*ppAlphaSurface)->lpAlpha = new BYTE[head.Width * head.Height];
		pAlpha = (*ppAlphaSurface)->lpAlpha;

		ZeroMemory( &ddsd, sizeof(ddsd) );
		ddsd.dwSize = sizeof(ddsd);

		if( !FAILED( hr = (*ppAlphaSurface)->lpSurface->GetDDrawSurface()->Lock(NULL,&ddsd,DDLOCK_WAIT|DDLOCK_READONLY,NULL) ) ) 
		{
			WORD *pwSur = (WORD *)ddsd.lpSurface;
			lPriPitch = ddsd.lPitch;
			//取得green的掩模, 以确定16位色为 555 | 565 格式
			//  以下实现565
			//  555尚未实现
			DWORD   dwGMask = ddsd.ddpfPixelFormat.dwGBitMask;

			//移到最后一行
			pwSur += (lPriPitch>>1) * (head.Height - 1);
			pAlpha += head.Width * (head.Height - 1);

			BYTE *pbTemp = pAlpha;
			WORD *pwTemp = pwSur;
			// 32位色压缩了的TGA, 
			if((head.ImageType == 10) && (head.PixelDepth == 32))
			{
				BYTE header;
				DWORD dwAttribute;
				DWORD dwColor;
				DWORD dwTemp =0;
				WORD Count;
				int	 nHang = 0;
				int  nTotal =0;
				float fAlpha;
				while(fread(&header,sizeof(BYTE),1, file))
				{
					if(header & 0x80)
					{
						Count = (header & 0x7F) + 1;
						nTotal += Count;
						fread(&dwColor,sizeof(DWORD),1, file);
						for(int i = 0; i < Count; i++)
						{
							//A R G B
							dwAttribute = ((dwColor & 0xff000000)>>24) & 0xff;
							*pAlpha	= dwAttribute;
							pAlpha++;
							fAlpha = (float)dwAttribute/255;
							if(fAlpha == 0) dwTemp = 0;
							else
							{
								dwTemp = ((dwColor & 0xff0000)>>8) & 0xf800;
								dwTemp += ((dwColor & 0xff00)>>5) & 0x7e0;
								dwTemp += ((dwColor & 0xff)>>3) & 0x1F;
							}
							*pwSur = dwTemp;
							pwSur++;
						}
					}
					else
					{	
						Count = (header & 0x7F) + 1;
						nTotal += Count;
						for(int i =0 ; i < Count; i++)
						{
							fread(&dwColor,sizeof(DWORD),1,file);
							dwAttribute = ((dwColor & 0xff000000)>>24) & 0xff;
							*pAlpha	= dwAttribute;
							pAlpha++;

							fAlpha =(float)dwAttribute/255;
							if(fAlpha == 0) dwTemp = 0;
							else
							{
								dwTemp = ((dwColor & 0xff0000)>>8) & 0xf800;
								dwTemp += ((dwColor & 0xff00)>>5) & 0x7e0;
								dwTemp += ((dwColor & 0xff)>>3) & 0x1F;
							}
							*pwSur = dwTemp;  
							pwSur++;
						}
					}
					if(nTotal >= head.Width)
					{
						if(++nHang == head.Height) break;
						nTotal = 0;
						pwTemp -= (lPriPitch>>1);
						pbTemp -= head.Width;

						pwSur  = pwTemp;
						pAlpha = pbTemp;
					}
				}
			}
			//32位色未压缩了的TGA
			else if((head.ImageType == 2) && (head.PixelDepth == 32))
			{
				DWORD dwAttribute;
				DWORD dwColor;
				DWORD dwTemp =0;
				int	 nHang = 0;
				int  nTotal =0;
				while(fread(&dwColor,sizeof(DWORD),1, file))
				{
					nTotal++;
					//A R G B  in DWORD
					dwAttribute = ((dwColor & 0xff000000)>>24) & 0xff;
					*pAlpha	= dwAttribute;
					pAlpha++;

					if(dwAttribute == 0) dwTemp = 0;
					else
					{
						dwTemp = ((dwColor & 0xff0000)>>8) & 0xf800;
						dwTemp += ((dwColor & 0xff00)>>5) & 0x7e0;
						dwTemp += ((dwColor & 0xff)>>3) & 0x1F;
					}
					*pwSur = dwTemp;
					pwSur++;

					if(nTotal >= head.Width)
					{
						if(++nHang == head.Height) break;
						nTotal = 0;
						pwTemp -= (lPriPitch>>1);
						pbTemp -= head.Width;

						pwSur  = pwTemp;
						pAlpha = pbTemp;
					}
				}
			}
			(*ppAlphaSurface)->lpSurface->GetDDrawSurface()->Unlock(NULL);
		//	(*ppAlphaSurface)->lpSurface->SetColorKey(0);
		}
		fclose(file);
	}
	else 
		return DD_FALSE;
    return DD_OK;
}


//-----------------------------------------------------------------------------
// Name: CDisplay::CreateSurfaceFromBitmap()
// Desc: Create a DirectDrawSurface from a bitmap resource or bitmap file.
//       Use MAKEINTRESOURCE() to pass a constant into strBMP.
//-----------------------------------------------------------------------------
HRESULT CDisplay::CreateSurfaceFromBitmap( CSurface** ppSurface,
                                           const TCHAR* strBMP,                                            
                                           DWORD dwDesiredWidth, 
                                           DWORD dwDesiredHeight )
{
    HRESULT        hr;
    HBITMAP        hBMP = NULL;
    BITMAP         bmp;
    DDSURFACEDESC2 ddsd;

    if( m_pDD == NULL || strBMP == NULL || ppSurface == NULL ) 
        return E_INVALIDARG;

    *ppSurface = NULL;

    //  Try to load the bitmap as a resource, if that fails, try it as a file
    hBMP = (HBITMAP) LoadImage( GetModuleHandle(NULL), strBMP, 
                                IMAGE_BITMAP, dwDesiredWidth, dwDesiredHeight, 
                                LR_CREATEDIBSECTION );
    if( hBMP == NULL )
    {
        hBMP = (HBITMAP) LoadImage( NULL, strBMP, 
                                    IMAGE_BITMAP, dwDesiredWidth, dwDesiredHeight, 
                                    LR_LOADFROMFILE | LR_CREATEDIBSECTION );
        if( hBMP == NULL )
            return E_FAIL;
    }

    // Get size of the bitmap
    GetObject( hBMP, sizeof(bmp), &bmp );

    // 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 | DDSCAPS_SYSTEMMEMORY;
    ddsd.dwWidth        = bmp.bmWidth;
    ddsd.dwHeight       = bmp.bmHeight;

    (*ppSurface) = new CSurface();
    if( FAILED( hr = (*ppSurface)->Create( m_pDD, &ddsd ) ) )
    {
        delete (*ppSurface);
        return hr;
    }

    // Draw the bitmap on this surface
    if( FAILED( hr = (*ppSurface)->DrawBitmap( hBMP, 0, 0, 0, 0 ) ) )
    {
        DeleteObject( hBMP );
        return hr;
    }

    DeleteObject( hBMP );

    return S_OK;
}     

HRESULT CDisplay::CreateSurfaceFromBIN(CSurface **ppSurface, const TCHAR *strBIN)
{
	HRESULT        hr;
    DDSURFACEDESC2 ddsd;
	BinHead		   head;
	long lPriPitch = 0;
	BYTE * pAlpha = NULL;

  
	if( m_pDD == NULL || strBIN == NULL )    
		return E_INVALIDARG;   
	*ppSurface = NULL;

	//Open BIN
	FILE* file = NULL;
	file = _tfopen(strBIN, _T("rb"));
	if(file)
	{
		fread(&head, sizeof(BinHead), 1, file);
		if((!strstr(head.szFileType, "PIC")) && (!strstr(head.szFileType, "NAl")))		
			return  E_FAIL;//DD_FALSE;
			
		ZeroMemory( &ddsd, sizeof(ddsd) );
		ddsd.dwSize         = sizeof(ddsd);
		ddsd.dwFlags        = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
		ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY;
		ddsd.dwWidth = head.Width;
		ddsd.dwHeight = head.Height;

		(*ppSurface) = new CSurface;
		if( FAILED( hr = (*ppSurface)->Create( m_pDD, &ddsd ) ) )
		{
			delete (*ppSurface);
			return hr;
		}

		ZeroMemory( &ddsd, sizeof(ddsd) );
		ddsd.dwSize = sizeof(ddsd);

		pAlpha=new BYTE[head.Height*head.Width];

		if( !FAILED( hr = (*ppSurface)->GetDDrawSurface()->Lock(NULL,&ddsd,DDLOCK_WAIT|DDLOCK_READONLY,NULL) ) ) 
		{
			WORD *pwSur = (WORD *)ddsd.lpSurface;
			lPriPitch = ddsd.lPitch;
			//Bin 的 16位色为 565 格式
			DWORD   dwGMask = ddsd.ddpfPixelFormat.dwGBitMask;
			BYTE *pbTemp = pAlpha;
			BYTE *pTemp = pAlpha;
			WORD *pwTemp = pwSur;
			BYTE Alpha;
			WORD dwcolor;
			WORD Temp;

			int nHang = 0;
			int nTotal =0;
			int i=0,j=0;

			// no alpha data
			if(strstr(head.szFileType, "NAl"))
			{				
				while(fread(&dwcolor,sizeof(WORD),1,file))		
				{
					*pwSur=dwcolor;	
					nTotal++;			
					if(nTotal>=head.Width)		
					{			
						pwTemp+=lPriPitch/2;
						pwSur=pwTemp;
						nTotal=0;				
						nHang++;				
						if(nHang==head.Height)						
							break;				
					}				
					else 
					{
						pwSur++;
					}
				}		
			} // have alpha data ...
			else   if(strstr(head.szFileType, "PIC"))			
			{			
				// read alpha data
				while(fread(&Alpha,sizeof(BYTE),1,file))		
				{			
					*pAlpha=Alpha;				
					nTotal++;			
					if(nTotal>=head.Width)				
					{				
						pbTemp+=head.Width;				
						pAlpha=pbTemp;				
						nTotal=0;				
						nHang++;				
						if(nHang==head.Height)					
							break;			
					}			
					else pAlpha++;		
				}		
				//nTotal++;		
				//nHang++;
				nTotal = 0;
				nHang = 0;
			
				// read picture bits...
				pAlpha=pTemp;
				while(fread(&dwcolor,sizeof(WORD),1,file))		
				{				    
					float i=*pAlpha/255;					
					if(*pAlpha==0)					
						Temp=0x1f;
					else
					{					
						//Temp  =(WORD)((dwcolor & 0xf800)*i + 0x8800 * (1-i))&0xf800;					
						//Temp +=(WORD)((dwcolor & 0x07e0)*i + 0x3e0 * (1-i))&0x07e0;					
						//Temp +=(WORD)((dwcolor & 0x001f)*i + 0x18 * (1-i))&0x001f;
						Temp = dwcolor;
					}
					*pwSur=Temp;//-+*
					nTotal++;
					if(nTotal>=head.Width)		
					{			
						pwTemp+=lPriPitch/2;
						pTemp+=head.Width;
						pwSur=pwTemp;
						pAlpha=pTemp;
						nTotal=0;				
						nHang++;				
						if(nHang==head.Height)						
							break;				
					}				
					else 
					{pwSur++;
					 pAlpha++;
					}
					
				}		
			}
			(*ppSurface)->GetDDrawSurface()->Unlock(NULL);
			(*ppSurface)->m_nCenterX=head.CenterX;
			(*ppSurface)->m_nCenterY=head.CenterY;
		}
		fclose(file);
	
	}
	else return DD_FALSE;
	return DD_OK;

}

//-----------------------------------------------------------------------------
// Name: CDisplay::CreateSurfaceFromText()
// Desc: Creates a DirectDrawSurface from a text string using hFont or the default 
//       GDI font if hFont is NULL.
//-----------------------------------------------------------------------------
HRESULT CDisplay::CreateSurfaceFromText( CSurface** ppSurface,
                                         HFONT hFont,const TCHAR* strText, 
                                         COLORREF crBackground, COLORREF crForeground )
{
    HDC                  hDC  = NULL;
    LPDIRECTDRAWSURFACE7 pDDS = NULL;
    HRESULT              hr;
    DDSURFACEDESC2       ddsd;
    SIZE                 sizeText;

    if( m_pDD == NULL || strText == NULL || ppSurface == NULL )
        return E_INVALIDARG;

    *ppSurface = NULL;

    hDC = GetDC( NULL );

    if( hFont )
        SelectObject( hDC, hFont );

    GetTextExtentPoint32( hDC, strText, _tcslen(strText), &sizeText );
    ReleaseDC( NULL, hDC );

    // 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        = sizeText.cx;
    ddsd.dwHeight       = sizeText.cy;

    (*ppSurface) = new CSurface();
    if( FAILED( hr = (*ppSurface)->Create( m_pDD, &ddsd ) ) )
    {
        delete (*ppSurface);
        return hr;
    }

    if( FAILED( hr = (*ppSurface)->DrawText( hFont, strText, 0, 0, 
                                             crBackground, crForeground ) ) )
        return hr;

    return S_OK;
}




//-----------------------------------------------------------------------------
// Name: 
// Desc: 
//-----------------------------------------------------------------------------
HRESULT CDisplay::Present()
{
    HRESULT hr;

    if( NULL == m_pddsFrontBuffer && NULL == m_pddsBackBuffer )
        return E_POINTER;