ddapi.cpp

网页游戏赤壁

// if surface is lost, run retore
// return value	:	TRUE if succeeded
BOOL DD_RestoreScreen( void )
{
	HRESULT ddrval;

	// reset primary surface
	if( DD_lpDDSFront )
	{
		ddrval = DD_lpDDSFront->Restore();
		if( ddrval != DD_OK )
		{
			int nErr=-1;
			switch( ddrval )
			{
			case	DDERR_GENERIC	:
				nErr = 1;
				break;
			case	DDERR_INCOMPATIBLEPRIMARY :
				nErr = 2;
				break;
			case	DDERR_IMPLICITLYCREATED	:
				nErr = 3;
				break;
			case	DDERR_INVALIDOBJECT :
				nErr = 4;
				break;
			case	DDERR_INVALIDPARAMS	:
				nErr = 5;
				break;
			case	DDERR_NOEXCLUSIVEMODE :
				nErr = 6;
				break;
			case	DDERR_OUTOFMEMORY	:
				nErr = 7;
				break;
			case	DDERR_UNSUPPORTED :
				nErr = 8;
				break;
			case	DDERR_WRONGMODE :
				nErr = 9;
				break;
			}
//			WriteErrorFile( "a.log", nErr );
			return FALSE;
		}
	}

	// reset secondary surface
	if( DD_lpDDSBack )
	{
		ddrval = DD_lpDDSBack->Restore();
		if( ddrval != DD_OK )
			return FALSE;
	}

	// reset palette, disband fade mode
	int nLevel = nFadeLevel;
	DD_FadeScreen( FALSE, 0 );

	// reset surfaces
	for( int i=0; i<MAX_SURFACE; i++)
	{
		if( DD_lppSurfaces[i] != NULL )
		{
			if( !DD_lppSurfaces[i]->Restore() ) 
				return FALSE;
		}
	}

	// reset fade mode
	for( int l=0; l < nLevel ; l++ )
		DD_FadeScreen( bFadeIn );

	// send surface lost error message to user's application
	PostMessage( hwndGame, WM_DD_SURFACELOST, 0, 0 );
	return TRUE;
} /* DD_RestoreScreen */

// draw from back buffer to front buffer
// pRect		:	rectangle region to update, full surface if it is NULL
// return value	:	TRUE if succeeded
BOOL DD_UpdateScreen( RECT *pRect/*=NULL*/ )
{
    HRESULT     ddrval;

	RECT rect;
	if( pRect == NULL )
	{
		rect.left = 0, rect.top = 0,
		rect.right = SCREEN_WIDTH, rect.bottom = SCREEN_HEIGHT;
	}
	else
	{
		rect.left = pRect->left, rect.top = pRect->top;
		rect.right = pRect->right, rect.bottom = pRect->bottom;
	}
    while( 1 )
    {
		ddrval = DD_lpDDSFront->BltFast( rect.left, rect.top, DD_lpDDSBack, &rect, DDBLTFAST_NOCOLORKEY );
        if( ddrval == DD_OK )
            break;
#ifdef	_DEBUG
		DD_getBltError( "DD_UpdateScreen", ddrval );
#endif
        if( ddrval == DDERR_SURFACELOST )
            if( !DD_RestoreScreen() )
                return FALSE;
        if( ddrval != DDERR_WASSTILLDRAWING )
            return FALSE;
    }
	return TRUE;
}	// DD_UpdateScreen()

// fill black color to front screen
// nColor		:	color index you want to fill, default is BLACK
// pRect		:	rectangle region to erase, full surface if it is NULL
// return value	:	TRUE if succeeded
BOOL DD_EraseFrontScreen( int nColor, RECT *pRect/*=NULL*/ )
{
    DDBLTFX     ddbltfx;
    HRESULT     ddrval;

    // Erase the background
    ddbltfx.dwSize = sizeof( ddbltfx );
    ddbltfx.dwFillColor = nColor;
    while( 1 )
    {
		ddrval = DD_lpDDSFront->Blt( pRect, NULL, NULL, DDBLT_COLORFILL, &ddbltfx );

        if( ddrval == DD_OK )
        {
            break;
        }
#ifdef	_DEBUG
		DD_getBltError( "DD_EraseFrontScreen", ddrval );
#endif
        if( ddrval == DDERR_SURFACELOST )
        {
            if( !DD_RestoreScreen() )
                return FALSE;
        }
        if( ddrval != DDERR_WASSTILLDRAWING )
        {
            return FALSE;
        }
    }
	return TRUE;
} /* DD_EraseFrontScreen() */

// fill black color to back screen
// nColor		:	color index you want to fill, default is BLACK
// pRect		:	rectangle region to erase, full surface if it is NULL
// return value	:	TRUE if succeeded
BOOL DD_EraseBackScreen( int nColor/*=0*/, RECT *pRect/*=NULL*/ )
{
    DDBLTFX     ddbltfx;
    HRESULT     ddrval;

    // Erase the background
    ddbltfx.dwSize = sizeof( ddbltfx );
    ddbltfx.dwFillColor = nColor;
    while( 1 )
    {
		ddrval = DD_lpDDSBack->Blt( pRect, NULL, NULL, DDBLT_COLORFILL, &ddbltfx );

        if( ddrval == DD_OK )
        {
            break;
        }
#ifdef	_DEBUG
		DD_getBltError( "DDEraseBackScreen", ddrval );
#endif
        if( ddrval == DDERR_SURFACELOST )
        {
            if( !DD_RestoreScreen() )
                return FALSE;
        }
        if( ddrval != DDERR_WASSTILLDRAWING )
        {
            return FALSE;
        }
    }
	return TRUE;
}	// DD_EraseBackScreen()


// fill black color to a given surface
// pSurface		:	surface to be erased
// nColor		:	color index you want to fill, default is BLACK
// pRect		:	rectangle region to erase, full surface if it is NULL
// return value	:	TRUE if succeeded
BOOL DD_EraseScreen( LPDIRECTDRAWSURFACE2 pSurface, int nColor, RECT *pRect/*=NULL*/ )
{
    DDBLTFX     ddbltfx;
    HRESULT     ddrval;

    // Erase the background
    ddbltfx.dwSize = sizeof( ddbltfx );
    ddbltfx.dwFillColor = nColor;
    while( 1 )
    {
		ddrval = pSurface->Blt( pRect, NULL, NULL, DDBLT_COLORFILL, &ddbltfx );

        if( ddrval == DD_OK )
        {
            break;
        }
#ifdef	_DEBUG
		DD_getBltError( "DDEraseScreen", ddrval );
#endif
        if( ddrval == DDERR_SURFACELOST )
        {
            if( !DD_RestoreScreen() )
                return FALSE;
        }
        if( ddrval != DDERR_WASSTILLDRAWING )
        {
            return FALSE;
        }
    }
	return TRUE;
}
//////////////////////////////

// fade screen
//////////////////////////////
// make screen fade in or fade out
// bIn			:	TRUE for fade in screen, else for fade out screen
// nMaxStep		:	ranges from 1 to 255, set to 0 if to reset this function
// return value	:	TRUE for end session
BOOL DD_FadeScreen( BOOL bIn , int nMaxStep /*=10*/ )
{
	RGBQUAD        rgb[256];
	PALETTEENTRY	pe[256];
	int nStep;

	// reset Fade mode
	if( nMaxStep == 0 ) 
	{
		if( nFadeLevel != 0 )
			DD_lpDDPal->SetEntries( 0, 0, 256, peFadeSave );
		nFadeLevel=0;	return TRUE;
	}

	// get palette entries and save it
	if( nFadeLevel == 0 )
	{
		if(DD_lpDDPal->GetEntries( 0, 0, 256, peFadeSave ) != DD_OK)
		{
			return	TRUE;
		}
	}

	// if end section, restore palette
	if( nFadeLevel == nMaxStep )
	{
		nFadeLevel = 0;
		DD_lpDDPal->SetEntries( 0, 0, 256, peFadeSave );
		return TRUE;
	}

	// set from palette entries to rgb
	for ( int j = 0; j< 256; j++ )
	{
		rgb[j].rgbRed = peFadeSave[j].peRed;
		rgb[j].rgbGreen = peFadeSave[j].peGreen;
		rgb[j].rgbBlue = peFadeSave[j].peBlue;
	}

	// fade in or fade out
	bFadeIn = bIn;
	if( bIn )		nStep=nFadeLevel;	// fade in
	else			nStep=nMaxStep-nFadeLevel;

	// do it
	for( int i=0; i<256; i++ )
	{
		rgb[i].rgbRed = peFadeSave[i].peRed*nStep/nMaxStep;
		rgb[i].rgbGreen = peFadeSave[i].peGreen*nStep/nMaxStep;
		rgb[i].rgbBlue = peFadeSave[i].peBlue*nStep/nMaxStep;
	}

	// set from rgb to palette entries
	for ( int k = 0; k< 256; k++ )
	{
		pe[k].peRed = rgb[k].rgbRed;
		pe[k].peGreen = rgb[k].rgbGreen;
		pe[k].peBlue = rgb[k].rgbBlue;
	}

	// set to palette
	if(DD_lpDDPal->SetEntries( 0, 0, 256, pe ) != DD_OK)
	{
		nFadeLevel = 0;
		DD_lpDDPal->SetEntries( 0, 0, 256, peFadeSave );
		return TRUE;
	}

	nFadeLevel ++;
	return	FALSE;
} /* DD_FadeScreen */

// fade out 
// nMaxStep		:	ranges from 1 to 255, set to 0 if to reset this function
// return value	:	TRUE for end session
BOOL DD_FadeOut( int nMaxStep )
{
	PALETTEENTRY	pe[256];
	int nStep;

	// get palette entries and save it
	if( nFadeLevel == 0 )
	{
		if(DD_lpDDPal->GetEntries( 0, 0, 256, peFadeSave ) != DD_OK)
		{
			return	TRUE;
		}
	}

	// if end section, restore palette
	if( nFadeLevel == (nMaxStep+1) )
	{
		nFadeLevel = 0;
		return TRUE;
	}
	// to computation the current step
	nStep= nMaxStep - nFadeLevel;
	// do it
	for( int i=0; i<256; i++ )
	{
		pe[i].peRed = peFadeSave[i].peRed*nStep/nMaxStep;
		pe[i].peGreen = peFadeSave[i].peGreen*nStep/nMaxStep;
		pe[i].peBlue = peFadeSave[i].peBlue*nStep/nMaxStep;
	}
	if(DD_lpDDPal->SetEntries( 0, 0, 256, pe ) != DD_OK)
	{
		nFadeLevel = 0;
		DD_lpDDPal->SetEntries( 0, 0, 256, peFadeSave );
		return TRUE;
	}

	nFadeLevel ++;
	return	FALSE;
} /* DD_FadeOut */

// fade in 
// nMaxStep		:	ranges from 1 to 255, set to 0 if to reset this function
// return value	:	TRUE for end session
BOOL DD_FadeIn(PALETTEENTRY	 * pe,PALETTEENTRY	* peFadeSave,int nMaxStep )
{
	// do it
	DD_lpDDPal->SetEntries( 0, 0, 256, pe ) ;

	for( int i=0; i<256; i++ )
	{
		if (pe[i].peRed <peFadeSave[i].peRed)
		{
			pe[i].peRed += nMaxStep ;
		}
		

		if (pe[i].peGreen <peFadeSave[i].peGreen )
		{
			pe[i].peGreen += nMaxStep ;
		}
		

		if (pe[i].peBlue <peFadeSave[i].peBlue )
		{
			pe[i].peBlue += nMaxStep ;
		}
		
	}

	// if end section, restore palette
	if( nFadeLevel == (nMaxStep+1) )
	{
		nFadeLevel = 0;
		DD_lpDDPal->SetEntries( 0, 0, 256, peFadeSave );
		return TRUE;
	}

	if(DD_lpDDPal->SetEntries( 0, 0, 256, pe ) != DD_OK)
	{
		nFadeLevel = 0;
		DD_lpDDPal->SetEntries( 0, 0, 256, peFadeSave );
		return TRUE;
	}

	nFadeLevel ++;

	return	FALSE;
} /* DD_FadeOut */

// fade out screen, from color to black
// nMaxStep		:	how much steps fade from begin to end
// nDelay		:	time each step should pause, in million second
void DD_FadeOutScreen( int nMaxStep, int nDelay )
{
	PALETTEENTRY	pe[256];

#ifdef	_DD_DEBUG
	return;
#endif //_DD_DEBUG

	// get palette entries and save it
	Assert( DD_lpDDPal != NULL );
	if(DD_lpDDPal->GetEntries( 0, 0, 256, peFadeSave ) != DD_OK)
	{	// error in get entry
		return;
	}

	if( nMaxStep <= 0 )	return;	// step error

	for( int nStep=nMaxStep-1; nStep>=0; nStep-- )
	{
		// do it
		for( int i=0; i<256; i++ )
		{
			pe[i].peRed = peFadeSave[i].peRed*nStep/nMaxStep;
			pe[i].peGreen = peFadeSave[i].peGreen*nStep/nMaxStep;
			pe[i].peBlue = peFadeSave[i].peBlue*nStep/nMaxStep;
		}
		if(DD_lpDDPal->SetEntries( 0, 0, 256, pe ) != DD_OK)
		{	// error in set entry
			DD_lpDDPal->SetEntries( 0, 0, 256, peFadeSave );
			return;
		}
		Sleep( nDelay );
	}
}	// DD_FadeOutScreen()

// fade in screen, from black to color, muset used with DD_FadeClear()
// nStep		:	how much steps fade from begin to end
// nDelay		:	time each step should pause, in million second
// pPal			:	the palette you want to display at last
void DD_FadeInScreen( int nMaxStep, int nDelay )
{
	PALETTEENTRY	pe[256];

#ifdef	_DD_DEBUG
	return;
#endif //_DD_DEBUG

	Assert( DD_lpDDPal != NULL );
	if( DD_lpDDPal == NULL )
	{
		OutputDebugString( "FadeInScreen Error(4): current palette is NULL!\n" );
		return;	// palette pointer cannot be NULL
	}

	if( nMaxStep <= 0 )
	{
		OutputDebugString( "DD_FadeInScreen Error(5): Step is less than 0!\n" );
		if( DD_lpDDPal->SetEntries( 0, 0, 256, peFadeSave ) != DD_OK )
		{
			OutputDebugString( "DD_FadeInScreen Error(0): Cannot set entries at last!\n" );
		}
		return;	// step error, set palette directly
	}

	for( int nStep=0; nStep<nMaxStep; nStep++ )
	{
		// do it
		for( int i=0; i<256; i++ )
		{
			pe[i].peRed = peFadeSave[i].peRed*nStep/nMaxStep;
			pe[i].peGreen = peFadeSave[i].peGreen*nStep/nMaxStep;
			pe[i].peBlue = peFadeSave[i].peBlue*nStep/nMaxStep;
		}
		if(DD_lpDDPal->SetEntries( 0, 0, 256, pe ) != DD_OK)
		{	// error in set entry
			OutputDebugString( "DD_FadeInScreen Error(1): Cannot set entries!\n" );
			DD_lpDDPal->SetEntries( 0, 0, 256, peFadeSave );
			return;
		}
		Sleep( nDelay );
	}
	if( DD_lpDDPal->SetEntries( 0, 0, 256, peFadeSave ) != DD_OK )
	{
		OutputDebugString( "DD_FadeInScreen Error(2): Cannot set entries at last!\n" );
	}
}	// DD_FadeInScreen()

// Restore saved palette from "peFadeSave" to spcecified palette 
// pointer. Usually used after DD_FadeOutScreen(), to reset the 
// palette at last, or maybe not useful after v0039.
// pPal			:	palette pointer to be restored
void DD_FadeRestore( LPDIRECTDRAWPALETTE pPal )
{

#ifdef	_DD_DEBUG
	return;
#endif //_DD_DEBUG