core_graphics.cpp

旋转图像Demo和其源代码

				}
				pDest += 2;
			}
			pDest += iPitch<<1;
		}
	}
	else if( ddsdSrc.ddpfPixelFormat.dwRGBBitCount == 8 )
	{
	}

	pGrDest->GetSurface()->Unlock( NULL );
	pGrSrc->GetSurface()->Unlock( NULL );

	return pGrDest;
}

cGraphics* cDirectDraw::RotateImageComplement( cGraphics* pGrDest, cGraphics* pGrSrc, COLORREF clrBack /* = 0  */)
{
	return pGrDest;
}

void cDirectDraw::DrawImageMask( cGraphics* pGrSrc, cGraphics* pGrMask, COLORREF clrMask, int left, int top, int mode/* =0  */)
{
	DDSURFACEDESC2 ddsdSrc;
	memset( &ddsdSrc, 0, sizeof(DDSURFACEDESC2) );
	ddsdSrc.dwSize = sizeof(DDSURFACEDESC2);
	pGrSrc->GetSurface()->Lock( NULL, &ddsdSrc, DDLOCK_WAIT, NULL );
	BYTE* pSrc = (BYTE*)ddsdSrc.lpSurface;
	BYTE* p1   = (BYTE*)ddsdSrc.lpSurface;

	DDSURFACEDESC2 ddsdMask;
	memset( &ddsdMask, 0, sizeof(DDSURFACEDESC2) );
	ddsdMask.dwSize = sizeof(DDSURFACEDESC2);
	pGrMask->GetSurface()->Lock( NULL, &ddsdMask, DDLOCK_WAIT, NULL );
	BYTE* pMask = (BYTE*)ddsdMask.lpSurface;
	BYTE* p2    = (BYTE*)ddsdMask.lpSurface;

	BYTE rKey, gKey, bKey;
	if( pGrSrc->m_bColorKey )
	{
		COLORREF clrKey = RGB2GDIColor( pGrSrc->m_clrKey );
		rKey = GetRValue( clrKey );
		gKey = GetGValue( clrKey );
		bKey = GetBValue( clrKey );
	}
	BYTE rMask, gMask, bMask;
	clrMask = RGB2GDIColor( clrMask );
	rMask   = GetRValue( clrMask );
	gMask   = GetGValue( clrMask );
	bMask   = GetBValue( clrMask );

	DDSURFACEDESC2 ddsdBack;
	memset( &ddsdBack, 0, sizeof(DDSURFACEDESC2) );
	ddsdBack.dwSize = sizeof(DDSURFACEDESC2);
	m_lpDDS_Back->Lock( NULL, &ddsdBack, DDLOCK_WAIT, NULL );
	BYTE* pBack = (BYTE*)ddsdBack.lpSurface;
	BYTE* p3    = (BYTE*)ddsdBack.lpSurface;

	if( ddsdBack.ddpfPixelFormat.dwRGBBitCount == 32 )
	{
		int iPitch = ((2-ddsdSrc.dwWidth&1)&1);
		pBack = p3 + top*ddsdBack.lPitch + (left<<2);
		for( int y=0; y<ddsdSrc.dwHeight; y++ )
		{
			for( int x=0; x<ddsdSrc.dwWidth; x++ )
			{
				if( !( pGrSrc->m_bColorKey && pSrc[0] == bKey && pSrc[1] == gKey && pSrc[2] == rKey )
					&& ( pMask[0] == bMask && pMask[1] == gMask && pMask[2] == rMask ) )
				{
					pBack[0] = pSrc[0];
					pBack[1] = pSrc[1];
					pBack[2] = pSrc[2];
				}
				pSrc  += 4;
				pMask += 4;
				pBack += 4;
			}
			pSrc  += iPitch<<2;
			pMask += iPitch<<2;
			pBack += iPitch<<2;
			pBack += ddsdBack.lPitch - ddsdSrc.lPitch;
		}
	}
	else if( ddsdBack.ddpfPixelFormat.dwRGBBitCount == 16 )
	{
		int iPitch = ((4-ddsdSrc.dwWidth&3)&3);
		pBack = p3 + top*ddsdBack.lPitch + (left<<1);
		for( int y=0; y<ddsdSrc.dwHeight; y++ )
		{
			for( int x=0; x<ddsdSrc.dwWidth; x++ )
			{
				if( !( pGrSrc->m_bColorKey && GetB(pSrc[0]) == bKey && GetG(pSrc[0], pSrc[1]) == gKey && GetR(pSrc[1]) == rKey )
					&& ( GetB(pMask[0]) == bMask && GetG(pMask[0], pMask[1]) == gMask && GetR(pMask[1]) == rMask ) )
				{
					pBack[0] = pSrc[0];
					pBack[1] = pSrc[1];
				}
				pSrc  += 2;
				pMask += 2;
				pBack += 2;
			}
			pSrc  += iPitch<<1;
			pMask += iPitch<<1;
			pBack += iPitch<<1;
			pBack += ddsdBack.lPitch - ddsdSrc.lPitch;
		}
	}

	m_lpDDS_Back->Unlock( NULL );
	pGrMask->GetSurface()->Unlock( NULL );
	pGrSrc->GetSurface()->Unlock( NULL );
}

cGraphics* cDirectDraw::ReverseImageV( cGraphics* pGrDest, cGraphics* pGrSrc )
{
	DDSURFACEDESC2 ddsdSrc;
	memset( &ddsdSrc, 0, sizeof(DDSURFACEDESC2) );
	ddsdSrc.dwSize = sizeof(DDSURFACEDESC2);
	pGrSrc->GetSurface()->Lock( NULL, &ddsdSrc, DDLOCK_WAIT, NULL );
	BYTE* pSrc = (BYTE*)ddsdSrc.lpSurface;

	if( pGrDest == NULL )
	{
		pGrDest = new cGraphics();
		pGrDest->Create( ddsdSrc.dwWidth, ddsdSrc.dwHeight );
	}
	if( pGrSrc->m_bColorKey )
		pGrDest->SetColorKey( pGrSrc->m_clrKey );
	DDSURFACEDESC2 ddsdDest;
	memset( &ddsdDest, 0, sizeof(DDSURFACEDESC2) );
	ddsdDest.dwSize = sizeof(DDSURFACEDESC2);
	pGrDest->GetSurface()->Lock( NULL, &ddsdDest, DDLOCK_WAIT, NULL );
	BYTE* pDest = (BYTE*)ddsdDest.lpSurface;

	if( ddsdSrc.ddpfPixelFormat.dwRGBBitCount == 32 )
	{
		int iPitch = ((2-ddsdDest.dwWidth&1)&1);
		pSrc += ddsdSrc.lPitch*ddsdSrc.dwHeight - ((iPitch+1)<<2);
		for( int y=0; y<ddsdDest.dwHeight; y++ )
		{
			for( int x=0; x<ddsdDest.dwWidth; x++ )
			{
				pDest[0] = pSrc[0];
				pDest[1] = pSrc[1];
				pDest[2] = pSrc[2];
				pDest   += 4;
				pSrc    -= 4;
			}
			pDest += iPitch<<2;
			pSrc  -= iPitch<<2; 
		}
	}
	else if( ddsdSrc.ddpfPixelFormat.dwRGBBitCount == 16 )
	{
		int iPitch = ((4-ddsdDest.dwWidth&3)&3);
		pSrc += ddsdSrc.lPitch*ddsdSrc.dwHeight - ((iPitch+1)<<1);
		for( int y=0; y<ddsdDest.dwHeight; y++ )
		{
			for( int x=0; x<ddsdDest.dwWidth; x++ )
			{
				pDest[0] = pSrc[0];
				pDest[1] = pSrc[1];
				pDest   += 2;
				pSrc    -= 2;
			}
			pDest += iPitch<<1;
			pSrc  -= iPitch<<1; 
		}
	}

	pGrDest->GetSurface()->Unlock( NULL );
	pGrSrc->GetSurface()->Unlock( NULL );

	return pGrDest;
}

cGraphics* cDirectDraw::ReverseImageH( cGraphics* pGrDest, cGraphics* pGrSrc )
{
	DDSURFACEDESC2 ddsdSrc;
	memset( &ddsdSrc, 0, sizeof(DDSURFACEDESC2) );
	ddsdSrc.dwSize = sizeof(DDSURFACEDESC2);
	pGrSrc->GetSurface()->Lock( NULL, &ddsdSrc, DDLOCK_WAIT, NULL );
	BYTE* pSrc = (BYTE*)ddsdSrc.lpSurface;

	if( pGrDest == NULL )
	{
		pGrDest = new cGraphics();
		pGrDest->Create( ddsdSrc.dwWidth, ddsdSrc.dwHeight );
	}
	if( pGrSrc->m_bColorKey )
		pGrDest->SetColorKey( pGrSrc->m_clrKey );
	DDSURFACEDESC2 ddsdDest;
	memset( &ddsdDest, 0, sizeof(DDSURFACEDESC2) );
	ddsdDest.dwSize = sizeof(DDSURFACEDESC2);
	pGrDest->GetSurface()->Lock( NULL, &ddsdDest, DDLOCK_WAIT, NULL );
	BYTE* pDest = (BYTE*)ddsdDest.lpSurface;

	int pos = 0;

	if( ddsdSrc.ddpfPixelFormat.dwRGBBitCount == 32 )
	{
		int iPitch = ((2-ddsdDest.dwWidth&1)&1);
		for( int y=0; y<ddsdDest.dwHeight; y++ )
		{
			pos += ddsdSrc.lPitch - ( (iPitch+1)<<2 );//the last pixel of line
			for( int x=0; x<ddsdDest.dwWidth; x++ )
			{
				pDest[0] = pSrc[pos];
				pDest[1] = pSrc[pos+1];
				pDest[2] = pSrc[pos+2];
				pDest += 4;
				pos   -= 4;
			}
			pDest += iPitch<<2;
			pos   += ddsdSrc.lPitch + 4;//move to next line
		}
	}
	else if( ddsdSrc.ddpfPixelFormat.dwRGBBitCount == 16 )
	{
		int iPitch = ((4-ddsdDest.dwWidth&3)&3);
		for( int y=0; y<ddsdDest.dwHeight; y++ )
		{
			pos += ddsdSrc.lPitch - ( (iPitch+1)<<1 );//the last pixel of line
			for( int x=0; x<ddsdDest.dwWidth; x++ )
			{
				pDest[0] = pSrc[pos];
				pDest[1] = pSrc[pos+1];
				pDest += 2;
				pos   -= 2;
			}
			pDest += iPitch<<1;
			pos   += ddsdSrc.lPitch + 2;//move to next line
		}
	}

	pGrDest->GetSurface()->Unlock( NULL );
	pGrSrc->GetSurface()->Unlock( NULL );

	return pGrDest;
}

DWORD cDirectDraw::RGB2GDIColor(COLORREF clrGDIColor )
{
	COLORREF rgbT;
	HDC hdc;
	DWORD dw = CLR_INVALID;
	DDSURFACEDESC2 ddsd;
	HRESULT hres;

	//
	//  use GDI SetPixel to color match for us
	//
	//if (rgb != CLR_INVALID && m_lpDDS->GetDC(&hdc) == DD_OK)
	if( clrGDIColor != CLR_INVALID && m_lpDDS_Back->GetDC( &hdc ) == DD_OK )
	{
		rgbT = GetPixel(hdc, 0, 0);             // save current pixel value
		SetPixel(hdc, 0, 0, clrGDIColor);               // set our value
		//m_lpDDS->ReleaseDC(hdc);
		m_lpDDS_Back->ReleaseDC( hdc );
	}

	//
	// now lock the surface so we can read back the converted color
	//
	ddsd.dwSize = sizeof(ddsd);
	//while ((hres = m_lpDDS->Lock(NULL, &ddsd, 0, NULL)) == DDERR_WASSTILLDRAWING);
	while ((hres = m_lpDDS_Back->Lock(NULL, &ddsd, 0, NULL)) == DDERR_WASSTILLDRAWING);

	if (hres == DD_OK)
	{
		//BYTE* p = (BYTE*)ddsd.lpSurface;
		//p[0] = 1;
		//p[1] = 2;
		//p[2] = 3;
		//p[3] = 4;
		dw  = *(DWORD *)ddsd.lpSurface;                     // get DWORD
		if(ddsd.ddpfPixelFormat.dwRGBBitCount < 32)
			dw &= (1 << ddsd.ddpfPixelFormat.dwRGBBitCount)-1;  // mask it to bpp
		//m_lpDDS->Unlock(NULL);
		m_lpDDS_Back->Unlock( NULL );
	}
	//
	//  now put the color that was there back.
	//
	if (clrGDIColor != CLR_INVALID && m_lpDDS_Back->GetDC(&hdc) == DD_OK)
	{
		SetPixel(hdc, 0, 0, rgbT);
		m_lpDDS_Back->ReleaseDC(hdc);
	}
	return dw;
}

HDC cDirectDraw::BeginText( COLORREF rgb/* =RGB(255 ,255,255)*/ )
{
	HDC hDC;
	m_lpDDS_Back->GetDC( &hDC );
	::SetBkMode( hDC, TRANSPARENT );
	::SetTextColor( hDC, rgb );
	return hDC;
}

void cDirectDraw::TextOut( HDC hDC, int left, int top, COLORREF rgb, TCHAR* chFormat, ... )
{
	::SetTextColor( hDC, rgb );
	TCHAR text[256];
	memset( text, 0, sizeof(TCHAR)*256 );
	va_list args;
	va_start( args, chFormat );
	_vstprintf( text, chFormat, args );
	va_end( args );
	::TextOut( hDC, left, top, text, _tcslen(text) );
}

void cDirectDraw::TextOut( HDC hDC, int left, int top, TCHAR* chFormat, ... )
{
	TCHAR text[256];
	memset( text, 0, sizeof(TCHAR)*256 );
	va_list args;
	va_start( args, chFormat );
	_vstprintf( text, chFormat, args );
	va_end( args );
	::TextOut( hDC, left, top, text, _tcslen(text) );
}

void cDirectDraw::EndText( HDC hDC )
{
	m_lpDDS_Back->ReleaseDC( hDC );
}

BOOL cDirectDraw::DisplayText( int left, int top, COLORREF rgb, TCHAR* chFormat, ... )
{
	HDC hDC = BeginText( rgb );
	TCHAR text[256];
	memset( text, 0, sizeof(TCHAR)*256 );
	va_list args;
	va_start( args, chFormat );
	_vstprintf( text, chFormat, args );
	va_end( args );
	::TextOut( hDC, left, top, text, _tcslen(text) );
	m_lpDDS_Back->ReleaseDC( hDC );
	return TRUE;
}


void cDirectDraw::ClearScreen( COLORREF clrBack )
{
	if( clrBack != 0 )
		clrBack = RGB2GDIColor(RGB(255,0,0));
	DDBLTFX ddBltFx;
	ddBltFx.dwSize=sizeof(ddBltFx);
	ddBltFx.dwFillColor= clrBack;
	m_lpDDS_Back->Blt(NULL,NULL,NULL,DDBLT_WAIT|DDBLT_COLORFILL,&ddBltFx);
}


BOOL cDirectDraw::PreFrame()
{
	return TRUE;
}

BOOL cDirectDraw::Frame()
{
	HRESULT hr;
	RECT rcWnd;
	if( m_bExclusive )
	{
		hr = m_lpDDS_Prim->Flip( m_lpDDS_Back, DDFLIP_WAIT );
	}
	else
	{
		memset( &rcWnd, 0, sizeof(RECT) );
		GetClientRect(m_hWnd,&rcWnd);
		ClientToScreen(m_hWnd,(LPPOINT)&rcWnd.left);
		ClientToScreen(m_hWnd,(LPPOINT)&rcWnd.right);

		hr = m_lpDDS_Prim->Blt( &rcWnd, m_lpDDS_Back, NULL, DDBLT_WAIT|DDBLT_KEYSRC, NULL );
		if( hr == DDERR_INVALIDPARAMS )
			hr = m_lpDDS_Prim->Blt( &rcWnd, m_lpDDS_Back, NULL, DDBLT_WAIT, NULL );
	}
	//switch( hr )
	//{
	//case DDERR_INVALIDPARAMS:
	//	MessageBox( GetActiveWindow(), "cDirectDraw::Frame 1", "ERROR", MB_OK );
	//	break;
	//case DDERR_SURFACELOST :
	//	MessageBox( GetActiveWindow(), "cDirectDraw::Frame 2", "ERROR", MB_OK );
	//	break;
	//case DDERR_SURFACEBUSY  :
	//	MessageBox( GetActiveWindow(), "cDirectDraw::Frame 3", "ERROR", MB_OK );
	//	break;
	//case DDERR_INVALIDOBJECT  :
	//	MessageBox( GetActiveWindow(), "cDirectDraw::Frame 4", "ERROR", MB_OK );
	//	break;
	//case DDERR_INVALIDRECT  :
	//	//MB( "DDERR_INVALIDRECT: \nRect:[%d][%d][%d][%d]", rcWnd.left, rcWnd.top, rcWnd.right, rcWnd.bottom );
	//	//MessageBox( GetActiveWindow(), "cDirectDraw::Frame 5", "ERROR", MB_OK ); //Bug here!!!
	//	break;
	//case DDERR_EXCEPTION   :
	//	MessageBox( GetActiveWindow(), "cDirectDraw::Frame 6", "ERROR", MB_OK );
	//	break;
	//case DDERR_UNSUPPORTED   :
	//	MessageBox( GetActiveWindow(), "cDirectDraw::Frame 7", "ERROR", MB_OK );
	//	break;
	//case DDERR_GENERIC    :
	//	MessageBox( GetActiveWindow(), "cDirectDraw::Frame 8", "ERROR", MB_OK );
	//	break;
	//case DDERR_NOBLTHW    :
	//	MessageBox( GetActiveWindow(), "cDirectDraw::Frame 9", "ERROR", MB_OK );
	//	break;
	//}
	//oldTime = newTime;
	if( DD_OK == hr )
		return TRUE;
	return TRUE;
}

BOOL cDirectDraw::SetDisplayMode( int width, int height )
{
	//取得桌面设置的颜色位数
	HWND hWndDesk = ::GetDesktopWindow();
	HDC  hDC = ::GetDC( hWndDesk );
	int currBitsPixel = GetDeviceCaps( hDC, BITSPIXEL );
	::ReleaseDC( hWndDesk, hDC );
	if( DD_OK != m_lpDD->SetDisplayMode(width, height, currBitsPixel, 0, DDSDM_STANDARDVGAMODE) )
		return FALSE;
	return TRUE;
}

BOOL cDirectDraw::Release()
{
	SAFE_RELEASE( m_lpDDS_Prim );
	SAFE_RELEASE( m_lpDDS_Back );
	m_input.Shutdown();
	m_keyboardDev.Free();
	m_mouseDev.Free();
	SAFE_RELEASE( m_lpDD );
	m_hWnd = NULL;

	return TRUE;
}

BYTE cDirectDraw::GetR( BYTE bt1 )
{
	return ( (BYTE)( ((BYTE)(bt1)&0xf8) ) );
}

BYTE cDirectDraw::GetG( BYTE bt0, BYTE bt1)
{
	return ( (BYTE)( (((BYTE)(bt1)&0x07)<<5) | (((BYTE)(bt0)&0xe0)>>3) ) );
}

BYTE cDirectDraw::GetB( BYTE bt0 )
{
	return ( (BYTE)( ( (BYTE)(bt0)&0x1f ) << 3 ) );
}

BYTE cDirectDraw::SetByte1( BYTE b, BYTE g )
{
	return ( (BYTE)( ((BYTE)(b) >> 3) | (((BYTE)(g) & 0x07 )<<5) ) );
}

BYTE cDirectDraw::SetByte2( BYTE g, BYTE r )
{
	return  ( (BYTE)( (((BYTE)(g) ) >> 5 ) | ((BYTE)(r) & 0xf8) ) );
}

BYTE cDirectDraw::GetR( PIXEL16 pixel )
{
	return (BYTE)( (PIXEL16)(pixel & 0xf800) >> 8 );
}

BYTE cDirectDraw::GetG( PIXEL16 pixel )
{
	return (BYTE)( (PIXEL16)( pixel & 0x07e0 ) >> 3 );
}

BYTE cDirectDraw::GetB( PIXEL16 pixel )
{
	return (BYTE)( (BYTE)( pixel & 0x001f ) << 3 );
}

COLORREF cDirectDraw::HI2RGB( PIXEL16 pixel )
{
	return (COLORREF)( (COLORREF)( (pixel&0xf800)<<8 ) | (COLORREF)( (pixel&0x07e0)<<5 ) | (COLORREF)( (pixel&0x001f)<<3 ) );
}

PIXEL16 cDirectDraw::RGB2HI( BYTE r, BYTE g, BYTE b )
{
	return (PIXEL16)( (PIXEL16)((r&0xf8)<<8) | (PIXEL16)((g&0xfc)<<3) | (BYTE)(b>>3) );
}

PIXEL16 cDirectDraw::RGB2HI( COLORREF rgb )
{
	return (PIXEL16)( (PIXEL16)((rgb&0x0000f8)<<8) | (PIXEL16)((rgb&0x00fc00)>>5) | (BYTE)((rgb&0xf80000)>>19) );
}

//////////////////////////////////////////////////////////////////////////