didcfgview.cpp

游戏编程精华02－含有几十个游戏编程例子

    // set the members
    bm->m_hbitmap;
    bm->m_lpBits = lpBits;
    bm->m_size.cx = width;
    bm->m_size.cy = height;

    return bm;
}





//-----------------------------------------------------------------------------
// Name: CleanUp()
// Desc: helper function to free resources
//-----------------------------------------------------------------------------
void DidcvBitmap::CleanUp()
{
    if( m_hbitmap )
    {
        DeleteObject( m_hbitmap );
        m_hbitmap = NULL;
    }

    m_lpBits = NULL;
    ZeroMemory( &m_size, sizeof( SIZE ) );
}




//-----------------------------------------------------------------------------
// Name: FigureSize()
// Desc: determines the size of the bitmap
//-----------------------------------------------------------------------------
void DidcvBitmap::FigureSize()
{
    BITMAP bm;

    if( NULL == m_hbitmap )
        return;

    if( 0 == GetObject( ( HGDIOBJ ) m_hbitmap, sizeof( BITMAP ),( LPVOID ) &bm ) )
        return;

    m_size.cx = abs( bm.bmWidth );
    m_size.cy = abs( bm.bmHeight );
}




//-----------------------------------------------------------------------------
// static members of DidcvAlphaBlend
//-----------------------------------------------------------------------------
DIDCV_ALPHABLEND DidcvAlphaBlend::s_alphaBlendProc = NULL;
HMODULE          DidcvAlphaBlend::s_hDll = NULL;
DWORD            DidcvAlphaBlend::s_dwNumClients = 0;




//-----------------------------------------------------------------------------
// Name: AddClient()
// Desc: static alpha blending initialization function
//       this bumps the reference count by one for each time it is called
//-----------------------------------------------------------------------------
BOOL DidcvAlphaBlend::AddClient()
{
    // try to the AlphaBlend function
    if( s_alphaBlendProc == NULL )
    {
        s_hDll = LoadLibrary( DIDCV_ALPHABLEND_DLL_NAME );

        if( s_hDll )
        {
            s_alphaBlendProc =( DIDCV_ALPHABLEND ) GetProcAddress( s_hDll, 
                                DIDCV_ALPHABLEND_PROC_NAME );
            if( !s_alphaBlendProc )
            { 
                FreeLibrary( s_hDll );
                s_hDll = NULL;
            }
        }
    }

    // bump the reference count
    s_dwNumClients ++;

    return( s_alphaBlendProc != NULL );
}




//-----------------------------------------------------------------------------
// Name: ReleaseClient()
// Desc: static alpha blend function called when a client detach
//-----------------------------------------------------------------------------
BOOL DidcvAlphaBlend::ReleaseClient()
{
    if( s_dwNumClients )
        s_dwNumClients --;

    // if reference count 0, then free resources
    if( s_dwNumClients == 0 )
    {
        s_alphaBlendProc = NULL;

        if( s_hDll )
        {
            FreeLibrary( s_hDll );
            s_hDll = NULL;
        }
    }

    return TRUE;
}



//-----------------------------------------------------------------------------
// Name: Blend()
// Desc: blends images by hand
//-----------------------------------------------------------------------------
BOOL DidcvAlphaBlend::Blend( VOID* lpDestBits, INT xStart, INT yStart, 
                             INT destWidth, INT destHeight, VOID* lpSrcBits, 
                             INT srcWidth, INT srcHeight )
{
    if( !lpDestBits || !lpSrcBits )
        return FALSE;

    // calculate the strides
    INT destStride = destWidth * 4;
    INT destOffset = xStart * 4;
    INT srcStride = srcWidth * 4;
    INT i, j;

    // clip the rectangle to draw to if necessary
    if( ( xStart + srcWidth ) >( destWidth ) )
        srcWidth = destWidth - xStart;
    if( ( yStart + srcHeight ) >( destHeight ) )
        srcHeight = destHeight - yStart;

    // the DIB bits are is indexed from bottom, left corner, so need to reverse horizontally
    BYTE* pDestStart = ( BYTE* ) lpDestBits + 
                       ( ( destHeight - yStart - 1 ) * destStride ) + destOffset;
    BYTE* pSrcStart =( BYTE* ) lpSrcBits + ( srcHeight - 1 ) * srcStride;
    BYTE destAlpha, srcAlpha;

    for( i = 0; i < srcHeight; i++ )
    {
        for( j = 0; j < srcStride; j += 4 )
        {
            // calculate src and dest alpha
            destAlpha = 0xff - pSrcStart[j + 3];
            srcAlpha = pSrcStart[j + 3];

            if( !srcAlpha ) continue;
            if( !destAlpha )
                *(( DWORD* )&pDestStart[j]) = *((DWORD *)&pSrcStart[j]);
            else
            {
                // set the R, G, B components
                pDestStart [j] =( pDestStart[j] * destAlpha + pSrcStart[j] * srcAlpha ) / 0xff;
                pDestStart [j+1] =( pDestStart[j+1] * destAlpha + pSrcStart[j+1] * srcAlpha ) / 0xff;
                pDestStart [j+2] =( pDestStart[j+2] * destAlpha + pSrcStart[j+2] * srcAlpha ) / 0xff;
            }
        }

        // advance the pointers
        pDestStart -= destStride;
        pSrcStart -= srcStride;
    }

    return TRUE;
}




//-----------------------------------------------------------------------------
// Name: Blend()
// Desc: blends a bitmap into the HDC
//-----------------------------------------------------------------------------
BOOL DidcvAlphaBlend::Blend( HDC hDC, INT xStart, INT yStart, INT width, 
                             INT height, HBITMAP hbitmap, const SIZE* lpSize )
{
    if( hDC == NULL || hbitmap == NULL || lpSize == NULL )
        return FALSE;

#if( WINVER >= 0x400 )

    HDC hDCbm = CreateCompatibleDC( hDC );
    if( hDCbm == NULL )
        return FALSE;

// this is done to resolve differences in header files
#ifdef AC_SRC_ALPHA
    BLENDFUNCTION blendfn = { AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };
#else
    BLENDFUNCTION blendfn = { AC_SRC_OVER, 0, 255, 0x1 };
#endif

    HGDIOBJ hOldBitmap = SelectObject( hDCbm, hbitmap );
    BOOL bRet = s_alphaBlendProc( hDC, xStart, yStart, width, height, 
                                  hDCbm, 0, 0, lpSize->cx, lpSize->cy, blendfn );
    SelectObject( hDCbm, hOldBitmap ); 
    DeleteDC( hDCbm );

    return TRUE;

#else

    return FALSE;

#endif

}




//-----------------------------------------------------------------------------
// Name: DidcvCallout()
// Desc: Constructor
//-----------------------------------------------------------------------------
DidcvCallout::DidcvCallout()
    : m_nViewRef( DIDCV_INVALID_ID ),
      m_lpDataRef( NULL ),
      m_lpOverlayBitmap( NULL )
{
    ZeroMemory( &m_devImgInfo, sizeof( DIDEVICEIMAGEINFO ) );
}




//-----------------------------------------------------------------------------
// Name: ~DidcvCallout()
// Desc: destructor
//-----------------------------------------------------------------------------
DidcvCallout::~DidcvCallout()
{
    if( m_lpOverlayBitmap )
    {
        delete m_lpOverlayBitmap;
        m_lpOverlayBitmap = NULL;
    }
}




//-----------------------------------------------------------------------------
// Name: GetObjID()
// Desc: returns the object ID
//-----------------------------------------------------------------------------
DWORD DidcvCallout::GetObjID() const
{
    return m_devImgInfo.dwObjID;
}




//-----------------------------------------------------------------------------
// Name: GetOverlayRect()
// Desc: returns the overlay rect for the callout
//-----------------------------------------------------------------------------
const RECT & DidcvCallout::GetOverlayRect() const
{
    return m_devImgInfo.rcOverlay;
}




//-----------------------------------------------------------------------------
// Name: GetCalloutRect()
// Desc: returns the callout rect, where the action text is displayed
//-----------------------------------------------------------------------------
const RECT & DidcvCallout::GetCalloutRect() const
{
    return m_devImgInfo.rcCalloutRect;
}




//-----------------------------------------------------------------------------
// Name: GetCalloutLine()
// Desc: returns the callout line segments as a const array
//-----------------------------------------------------------------------------
const POINT* DidcvCallout::GetCalloutLine( DWORD* lpNumPts ) const
{
    if( NULL != lpNumPts )
        *lpNumPts = m_devImgInfo.dwcValidPts;

    return m_devImgInfo.rgptCalloutLine;
}




//-----------------------------------------------------------------------------
// Name: GetTextAlign()
// Desc: return the text alignment for the callout
//-----------------------------------------------------------------------------
DWORD DidcvCallout::GetTextAlign() const
{
    return m_devImgInfo.dwTextAlign;
}




//-----------------------------------------------------------------------------
// Name: GetOverlayOffset()
// Desc: returns the index of the callout in the original image info array
//       returned by DirectInputDevice8::GetImage()
//-----------------------------------------------------------------------------
DWORD DidcvCallout::GetOverlayOffset() const
{
    return m_devImgInfo.dwViewID;
}




//-----------------------------------------------------------------------------
// Name: GetAssociatedViewID()
// Desc: returns the internally assigned( by DIDCfgView ) identifier of a
//       view that this callout is assicated with
//-----------------------------------------------------------------------------
INT DidcvCallout::GetAssociatedViewID() const
{
    return m_nViewRef;
}




//-----------------------------------------------------------------------------
// Name: SetAssociatedViewID()
// Desc: sets the view with which this callout is associated with
//-----------------------------------------------------------------------------
void DidcvCallout::SetAssociatedViewID( INT nViewRef )
{
    m_nViewRef = nViewRef;
}




//-----------------------------------------------------------------------------
// Name: HitTest()
// Desc: tests to determines whether a point is contained the associated
//       regions of this callout.  coordinates are relative to the left top
//       corner of the image
//-----------------------------------------------------------------------------
DWORD DidcvCallout::HitTest( LPPOINT lpPt ) const
{
    if( NULL == lpPt )
        return FALSE;

    // if in overlay rectangle, then hit
    //    if( PtInRect( &( m_devImgInfo.rcOverlay ), *lpPt ) )
    //        return TRUE;

    // if in callout rectangle, then hit
    if( PtInRect( &( m_devImgInfo.rcCalloutRect ), *lpPt ) )
        return TRUE;

    return FALSE;
}




//-----------------------------------------------------------------------------
// Name: DrawOverlay()
// Desc: draws the overlay image
//-----------------------------------------------------------------------------
DWORD DidcvCallout::DrawOverlay( HDC hDC, VOID* lpBits, INT width, 
                                 INT height, const POINT* ptOrigin )
{
    BOOL res = FALSE;

    if( m_lpOverlayBitmap )
    {
        // alpha blend with pointers only
        if( lpBits )
            res = m_lpOverlayBitmap->Blend( lpBits, 
                        m_devImgInfo.rcOverlay.left + ptOrigin->x, 
                        m_devImgInfo.rcOverlay.top  + ptOrigin->y, 
                        width, height );

        if( !res )
        {
            // try alpha blending with hDC
            res = m_lpOverlayBitmap->Blend( hDC, m_devImgInfo.rcOverlay.left, 
                                            m_devImgInfo.rcOverlay.top );
        }
    }

    return res;
}




//-----------------------------------------------------------------------------
// Name: SetDataRef()
// Desc: attach a pointer to the callout data relevant to this callout
//-----------------------------------------------------------------------------
void DidcvCallout::SetDataRef( const DidcvCalloutData* lpData )
{
    m_lpDataRef = lpData;
}




//------------------------------------------