开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 查看源码
ddutil.cpp
资源名称：Visual_C++GameDevelop.rar　[点击查看]
上传用户：sycq158
上传日期：2008-10-22
资源大小：15361k
文件大小：31k
源码类别：

游戏

开发平台：

Visual C++

ddutil.cpp：源码内容
  1. //-----------------------------------------------------------------------------
  2. // File: ddutil.cpp
  3. //
  4. // Desc: DirectDraw framewark classes. Feel free to use this class as a 
  5. //       starting point for adding extra functionality.
  6. //
  7. //
  8. // Copyright (c) 1995-1999 Microsoft Corporation. All rights reserved.
  9. //-----------------------------------------------------------------------------
  10. #define STRICT
  11. #include <tchar.h>
  12. #include <windows.h>
  13. #include <windowsx.h>
  14. #include <ddraw.h>
  15. #include "ddutil.h"
  16. #include "dxutil.h"
  23. //-----------------------------------------------------------------------------
  24. // Name: CDisplay()
  25. // Desc:
  26. //-----------------------------------------------------------------------------
  27. CDisplay::CDisplay()
  28. {
  29.     m_pDD                = NULL;
  30.     m_pddsFrontBuffer    = NULL;
  31.     m_pddsBackBuffer     = NULL;
  32.     m_pddsBackBufferLeft = NULL;
  33. }
  38. //-----------------------------------------------------------------------------
  39. // Name: ~CDisplay()
  40. // Desc:
  41. //-----------------------------------------------------------------------------
  42. CDisplay::~CDisplay()
  43. {
  44.     DestroyObjects();
  45. }
  50. //-----------------------------------------------------------------------------
  51. // Name: DestroyObjects()
  52. // Desc:
  53. //-----------------------------------------------------------------------------
  54. HRESULT CDisplay::DestroyObjects()
  55. {
  56.     SAFE_RELEASE( m_pddsBackBufferLeft );
  57.     SAFE_RELEASE( m_pddsBackBuffer );
  58.     SAFE_RELEASE( m_pddsFrontBuffer );
  60.     if( m_pDD )
  61.         m_pDD->SetCooperativeLevel( m_hWnd, DDSCL_NORMAL );
  63.     SAFE_RELEASE( m_pDD );
  65.     return S_OK;
  66. }
  71. //-----------------------------------------------------------------------------
  72. // Name: CreateFullScreenDisplay()
  73. // Desc:
  74. //-----------------------------------------------------------------------------
  75. HRESULT CDisplay::CreateFullScreenDisplay( HWND hWnd, DWORD dwWidth,
  76.                                            DWORD dwHeight, DWORD dwBPP )
  77. {
  78.     HRESULT hr;
  80.     // Cleanup anything from a previous call
  81.     DestroyObjects();
  83.     // DDraw stuff begins here
  84.     if( FAILED( hr = DirectDrawCreateEx( NULL, (VOID**)&m_pDD,
  85.                                          IID_IDirectDraw7, NULL ) ) )
  86.         return E_FAIL;
  88.     // Set cooperative level
  89.     hr = m_pDD->SetCooperativeLevel( hWnd, DDSCL_EXCLUSIVE|DDSCL_FULLSCREEN );
  90.     if( FAILED(hr) )
  91.         return E_FAIL;
  93.     // Set the display mode
  94. hr = m_pDD->SetDisplayMode( dwWidth, dwHeight, dwBPP, 0, 0 ) ;
  95.     if( FAILED( hr ))
  96.         return E_FAIL;
  98.     // Create primary surface (with backbuffer attached)
  99.     DDSURFACEDESC2 ddsd;
  100.     ZeroMemory( &ddsd, sizeof( ddsd ) );
  101.     ddsd.dwSize            = sizeof( ddsd );
  102.     ddsd.dwFlags           = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
  103.     ddsd.ddsCaps.dwCaps    = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP |
  104.                              DDSCAPS_COMPLEX | DDSCAPS_3DDEVICE;
  105.     ddsd.dwBackBufferCount = 1;
  107.     if( FAILED( hr = m_pDD->CreateSurface( &ddsd, &m_pddsFrontBuffer,
  108.                                            NULL ) ) )
  109.         return E_FAIL;
  111.     // Get a pointer to the back buffer
  112.     DDSCAPS2 ddscaps;
  113.     ZeroMemory( &ddscaps, sizeof( ddscaps ) );
  114.     ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
  116.     if( FAILED( hr = m_pddsFrontBuffer->GetAttachedSurface( &ddscaps,
  117.                                                             &m_pddsBackBuffer ) ) )
  118.         return E_FAIL;
  120.     m_pddsBackBuffer->AddRef();
  122.     m_hWnd      = hWnd;
  123.     m_bWindowed = FALSE;
  124.     UpdateBounds();
  126.     return S_OK;
  127. }
  128.     
  132. //-----------------------------------------------------------------------------
  133. // Name: CreateWindowedDisplay()
  134. // Desc:
  135. //-----------------------------------------------------------------------------
  136. HRESULT CDisplay::CreateWindowedDisplay( HWND hWnd, DWORD dwWidth, DWORD dwHeight )
  137. {
  138.     HRESULT hr;
  140.     // Cleanup anything from a previous call
  141.     DestroyObjects();
  143.     // DDraw stuff begins here
  144.     if( FAILED( hr = DirectDrawCreateEx( NULL, (VOID**)&m_pDD,
  145.                                          IID_IDirectDraw7, NULL ) ) )
  146.         return E_FAIL;
  148.     // Set cooperative level
  149.     hr = m_pDD->SetCooperativeLevel( hWnd, DDSCL_NORMAL );
  150.     if( FAILED(hr) )
  151.         return E_FAIL;
  153.     RECT  rcWork;
  154.     RECT  rc;
  155.     DWORD dwStyle;
  157.     // If we are still a WS_POPUP window we should convert to a normal app
  158.     // window so we look like a windows app.
  159.     dwStyle  = GetWindowStyle( hWnd );
  160.     dwStyle &= ~WS_POPUP;
  161.     dwStyle |= WS_OVERLAPPED | WS_CAPTION | WS_THICKFRAME | WS_MINIMIZEBOX;
  162.     SetWindowLong( hWnd, GWL_STYLE, dwStyle );
  164.     // Aet window size
  165.     SetRect( &rc, 0, 0, dwWidth, dwHeight );
  167.     AdjustWindowRectEx( &rc, GetWindowStyle(hWnd), GetMenu(hWnd) != NULL,
  168.                         GetWindowExStyle(hWnd) );
  170.     SetWindowPos( hWnd, NULL, 0, 0, rc.right-rc.left, rc.bottom-rc.top,
  171.                   SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE );
  173.     SetWindowPos( hWnd, HWND_NOTOPMOST, 0, 0, 0, 0,
  174.                   SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE );
  176.     //  Make sure our window does not hang outside of the work area
  177.     SystemParametersInfo( SPI_GETWORKAREA, 0, &rcWork, 0 );
  178.     GetWindowRect( hWnd, &rc );
  179.     if( rc.left < rcWork.left ) rc.left = rcWork.left;
  180.     if( rc.top  < rcWork.top )  rc.top  = rcWork.top;
  181.     SetWindowPos( hWnd, NULL, rc.left, rc.top, 0, 0,
  182.                   SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE );
  184.     LPDIRECTDRAWCLIPPER pcClipper;
  185.     
  186.     // Create the primary surface
  187.     DDSURFACEDESC2 ddsd;
  188.     ZeroMemory( &ddsd, sizeof( ddsd ) );
  189.     ddsd.dwSize         = sizeof( ddsd );
  190.     ddsd.dwFlags        = DDSD_CAPS;
  191.     ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
  193.     if( FAILED( m_pDD->CreateSurface( &ddsd, &m_pddsFrontBuffer, NULL ) ) )
  194.         return E_FAIL;
  196.     // Create the backbuffer surface
  197.     ddsd.dwFlags        = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;    
  198.     ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE;
  199.     ddsd.dwWidth        = dwWidth;
  200.     ddsd.dwHeight       = dwHeight;
  202.     if( FAILED( hr = m_pDD->CreateSurface( &ddsd, &m_pddsBackBuffer, NULL ) ) )
  203.         return E_FAIL;
  205.     if( FAILED( hr = m_pDD->CreateClipper( 0, &pcClipper, NULL ) ) )
  206.         return E_FAIL;
  208.     if( FAILED( hr = pcClipper->SetHWnd( 0, hWnd ) ) )
  209.     {
  210.         pcClipper->Release();
  211.         return E_FAIL;
  212.     }
  214.     if( FAILED( hr = m_pddsFrontBuffer->SetClipper( pcClipper ) ) )
  215.     {
  216.         pcClipper->Release();
  217.         return E_FAIL;
  218.     }
  220.     // Done with clipper
  221.     pcClipper->Release();
  223.     m_hWnd      = hWnd;
  224.     m_bWindowed = TRUE;
  225.     UpdateBounds();
  227.     return S_OK;
  228. }
  233. //-----------------------------------------------------------------------------
  234. // Name: 
  235. // Desc: 
  236. //-----------------------------------------------------------------------------
  237. HRESULT CDisplay::CreateSurface( CSurface** ppSurface,
  238.                                  DWORD dwWidth, DWORD dwHeight )
  239. {
  240.     if( NULL == m_pDD )
  241.         return E_POINTER;
  242.     if( NULL == ppSurface )
  243.         return E_INVALIDARG;
  245.     HRESULT        hr;
  246.     DDSURFACEDESC2 ddsd;
  247.     ZeroMemory( &ddsd, sizeof( ddsd ) );
  248.     ddsd.dwSize         = sizeof( ddsd );
  249.     ddsd.dwFlags        = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; 
  250.     ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
  251.     ddsd.dwWidth        = dwWidth;
  252.     ddsd.dwHeight       = dwHeight;
  254.     (*ppSurface) = new CSurface();
  255.     if( FAILED( hr = (*ppSurface)->Create( m_pDD, &ddsd ) ) )
  256.     {
  257.         delete (*ppSurface);
  258.         return hr;
  259.     }
  261.     return S_OK;
  262. }
  267. //-----------------------------------------------------------------------------
  268. // Name: CDisplay::CreateSurfaceFromBitmap()
  269. // Desc: Create a DirectDrawSurface from a bitmap resource or bitmap file.
  270. //       Use MAKEINTRESOURCE() to pass a constant into strBMP.
  271. //-----------------------------------------------------------------------------
  272. HRESULT CDisplay::CreateSurfaceFromBitmap( CSurface** ppSurface,
  273.                                            TCHAR* strBMP,                                            
  274.                                            DWORD dwDesiredWidth, 
  275.                                            DWORD dwDesiredHeight )
  276. {
  277.     HRESULT        hr;
  278.     HBITMAP        hBMP = NULL;
  279.     BITMAP         bmp;
  280.     DDSURFACEDESC2 ddsd;
  282.     if( m_pDD == NULL || strBMP == NULL || ppSurface == NULL ) 
  283.         return E_INVALIDARG;
  285.     *ppSurface = NULL;
  287.     //  Try to load the bitmap as a resource, if that fails, try it as a file
  288.     hBMP = (HBITMAP) LoadImage( GetModuleHandle(NULL), strBMP, 
  289.                                 IMAGE_BITMAP, dwDesiredWidth, dwDesiredHeight, 
  290.                                 LR_CREATEDIBSECTION );
  291.     if( hBMP == NULL )
  292.     {
  293.         hBMP = (HBITMAP) LoadImage( NULL, strBMP, 
  294.                                     IMAGE_BITMAP, dwDesiredWidth, dwDesiredHeight, 
  295.                                     LR_LOADFROMFILE | LR_CREATEDIBSECTION );
  296.         if( hBMP == NULL )
  297.             return E_FAIL;
  298.     }
  300.     // Get size of the bitmap
  301.     GetObject( hBMP, sizeof(bmp), &bmp );
  303.     // Create a DirectDrawSurface for this bitmap
  304.     ZeroMemory( &ddsd, sizeof(ddsd) );
  305.     ddsd.dwSize         = sizeof(ddsd);
  306.     ddsd.dwFlags        = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
  307.     ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
  308.     ddsd.dwWidth        = bmp.bmWidth;
  309.     ddsd.dwHeight       = bmp.bmHeight;
  311.     (*ppSurface) = new CSurface();
  312.     if( FAILED( hr = (*ppSurface)->Create( m_pDD, &ddsd ) ) )
  313.     {
  314.         delete (*ppSurface);
  315.         return hr;
  316.     }
  318.     // Draw the bitmap on this surface
  319.     if( FAILED( hr = (*ppSurface)->DrawBitmap( hBMP, 0, 0, 0, 0 ) ) )
  320.     {
  321.         DeleteObject( hBMP );
  322.         return hr;
  323.     }
  325.     DeleteObject( hBMP );
  327.     return S_OK;
  328. }
  333. //-----------------------------------------------------------------------------
  334. // Name: CDisplay::CreateSurfaceFromText()
  335. // Desc: Creates a DirectDrawSurface from a text string using hFont or the default 
  336. //       GDI font if hFont is NULL.
  337. //-----------------------------------------------------------------------------
  338. HRESULT CDisplay::CreateSurfaceFromText( CSurface** ppSurface,
  339.                                          HFONT hFont, const TCHAR* strText, 
  340.                                          COLORREF crBackground, COLORREF crForeground )
  341. {
  342.     HDC                  hDC  = NULL;
  343.     LPDIRECTDRAWSURFACE7 pDDS = NULL;
  344.     HRESULT              hr;
  345.     DDSURFACEDESC2       ddsd;
  346.     SIZE                 sizeText;
  348.     if( m_pDD == NULL || strText == NULL || ppSurface == NULL )
  349.         return E_INVALIDARG;
  351.     *ppSurface = NULL;
  353.     hDC = GetDC( NULL );
  355.     if( hFont )
  356.         SelectObject( hDC, hFont );
  358.     GetTextExtentPoint32( hDC, strText, _tcslen(strText), &sizeText );
  359.     ReleaseDC( NULL, hDC );
  361.     // Create a DirectDrawSurface for this bitmap
  362.     ZeroMemory( &ddsd, sizeof(ddsd) );
  363.     ddsd.dwSize         = sizeof(ddsd);
  364.     ddsd.dwFlags        = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
  365.     ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
  366.     ddsd.dwWidth        = sizeText.cx;
  367.     ddsd.dwHeight       = sizeText.cy;
  369.     (*ppSurface) = new CSurface();
  370.     if( FAILED( hr = (*ppSurface)->Create( m_pDD, &ddsd ) ) )
  371.     {
  372.         delete (*ppSurface);
  373.         return hr;
  374.     }
  376.     if( FAILED( hr = (*ppSurface)->DrawText( hFont, strText, 0, 0, 
  377.                                              crBackground, crForeground ) ) )
  378.         return hr;
  380.     return S_OK;
  381. }
  386. //-----------------------------------------------------------------------------
  387. // Name: 
  388. // Desc: 
  389. //-----------------------------------------------------------------------------
  390. HRESULT CDisplay::Present()
  391. {
  392.     HRESULT hr;
  394.     if( NULL == m_pddsFrontBuffer && NULL == m_pddsBackBuffer )
  395.         return E_POINTER;
  397.     while( 1 )
  398.     {
  399.         if( m_bWindowed )
  400.             hr = m_pddsFrontBuffer->Blt( &m_rcWindow, m_pddsBackBuffer,
  401.                                          NULL, DDBLT_WAIT, NULL );
  402.         else
  403.             hr = m_pddsFrontBuffer->Flip( NULL, 0 );
  405.         if( hr == DDERR_SURFACELOST )
  406.         {
  407.             m_pddsFrontBuffer->Restore();
  408.             m_pddsBackBuffer->Restore();
  409.         }
  411.         if( hr != DDERR_WASSTILLDRAWING )
  412.             return hr;
  413.     }
  414. }
  419. //-----------------------------------------------------------------------------
  420. // Name: 
  421. // Desc: 
  422. //-----------------------------------------------------------------------------
  423. HRESULT CDisplay::ShowBitmap( HBITMAP hbm, LPDIRECTDRAWPALETTE pPalette )
  424. {
  425.     if( NULL == m_pddsFrontBuffer ||  NULL == m_pddsBackBuffer )
  426.         return E_POINTER;
  428.     // Set the palette before loading the bitmap
  429.     if( pPalette )
  430.         m_pddsFrontBuffer->SetPalette( pPalette );
  432.     CSurface backBuffer;
  433.     backBuffer.Create( m_pddsBackBuffer );
  435.     if( FAILED( backBuffer.DrawBitmap( hbm, 0, 0, 0, 0 ) ) )
  436.         return E_FAIL;
  438.     return Present();
  439. }
  444. //-----------------------------------------------------------------------------
  445. // Name: 
  446. // Desc: 
  447. //-----------------------------------------------------------------------------
  448. HRESULT CDisplay::ColorKeyBlt( DWORD x, DWORD y, LPDIRECTDRAWSURFACE7 pdds,
  449.                                RECT* prc )
  450. {
  451.     if( NULL == m_pddsBackBuffer )
  452.         return E_POINTER;
  454.     return m_pddsBackBuffer->BltFast( x, y, pdds, prc, DDBLTFAST_SRCCOLORKEY );
  455. }
  460. //-----------------------------------------------------------------------------
  461. // Name: 
  462. // Desc: 
  463. //-----------------------------------------------------------------------------
  464. HRESULT CDisplay::Blt( DWORD x, DWORD y, LPDIRECTDRAWSURFACE7 pdds, RECT* prc,
  465.                        DWORD dwFlags )
  466. {
  467.     if( NULL == m_pddsBackBuffer )
  468.         return E_POINTER;
  470.     return m_pddsBackBuffer->BltFast( x, y, pdds, prc, dwFlags );
  471. }
  476. //-----------------------------------------------------------------------------
  477. // Name: 
  478. // Desc: 
  479. //-----------------------------------------------------------------------------
  480. HRESULT CDisplay::Blt( DWORD x, DWORD y, CSurface* pSurface, RECT* prc )
  481. {
  482.     if( NULL == pSurface )
  483.         return E_INVALIDARG;
  485.     if( pSurface->IsColorKeyed() )
  486.         return Blt( x, y, pSurface->GetDDrawSurface(), prc, DDBLTFAST_SRCCOLORKEY );
  487.     else
  488.         return Blt( x, y, pSurface->GetDDrawSurface(), prc, 0L );
  489. }
  494. //-----------------------------------------------------------------------------
  495. // Name: 
  496. // Desc: 
  497. //-----------------------------------------------------------------------------
  498. HRESULT CDisplay::Clear( DWORD dwColor )
  499. {
  500.     if( NULL == m_pddsBackBuffer )
  501.         return E_POINTER;
  503.     // Erase the background
  504.     DDBLTFX ddbltfx;
  505.     ZeroMemory( &ddbltfx, sizeof(ddbltfx) );
  506.     ddbltfx.dwSize      = sizeof(ddbltfx);
  507.     ddbltfx.dwFillColor = dwColor;
  509.     return m_pddsBackBuffer->Blt( NULL, NULL, NULL, DDBLT_COLORFILL, &ddbltfx );
  510. }
  515. //-----------------------------------------------------------------------------
  516. // Name: 
  517. // Desc: 
  518. //-----------------------------------------------------------------------------
  519. HRESULT CDisplay::SetPalette( LPDIRECTDRAWPALETTE pPalette )
  520. {
  521.     if( NULL == m_pddsFrontBuffer )
  522.         return E_POINTER;
  524.     return m_pddsFrontBuffer->SetPalette( pPalette );
  525. }
  530. //-----------------------------------------------------------------------------
  531. // Name: 
  532. // Desc: 
  533. //-----------------------------------------------------------------------------
  534. HRESULT CDisplay::CreatePaletteFromBitmap( LPDIRECTDRAWPALETTE* ppPalette,
  535.                                            const TCHAR* strBMP )
  536. {
  537.     HRSRC             hResource      = NULL;
  538.     RGBQUAD*          pRGB           = NULL;
  539.     BITMAPINFOHEADER* pbi = NULL;
  540.     PALETTEENTRY      aPalette[256];
  541.     HANDLE            hFile = NULL;
  542.     DWORD             iColor;
  543.     DWORD             dwColors;
  544.     BITMAPFILEHEADER  bf;
  545.     BITMAPINFOHEADER  bi;
  546.     DWORD             dwBytesRead;
  548.     if( m_pDD == NULL || strBMP == NULL || ppPalette == NULL )
  549.         return E_INVALIDARG;
  551.     *ppPalette = NULL;
  553.     //  Try to load the bitmap as a resource, if that fails, try it as a file
  554.     hResource = FindResource( NULL, strBMP, RT_BITMAP );
  555.     if( hResource )
  556.     {
  557.         pbi = (LPBITMAPINFOHEADER) LockResource( LoadResource( NULL, hResource ) );       
  558.         if( NULL == pbi )
  559.             return E_FAIL;
  561.         pRGB = (RGBQUAD*) ( (BYTE*) pbi + pbi->biSize );
  563.         // Figure out how many colors there are
  564.         if( pbi == NULL || pbi->biSize < sizeof(BITMAPINFOHEADER) )
  565.             dwColors = 0;
  566.         else if( pbi->biBitCount > 8 )
  567.             dwColors = 0;
  568.         else if( pbi->biClrUsed == 0 )
  569.             dwColors = 1 << pbi->biBitCount;
  570.         else
  571.             dwColors = pbi->biClrUsed;
  573.         //  A DIB color table has its colors stored BGR not RGB
  574.         //  so flip them around.
  575.         for( iColor = 0; iColor < dwColors; iColor++ )
  576.         {
  577.             aPalette[iColor].peRed   = pRGB[iColor].rgbRed;
  578.             aPalette[iColor].peGreen = pRGB[iColor].rgbGreen;
  579.             aPalette[iColor].peBlue  = pRGB[iColor].rgbBlue;
  580.             aPalette[iColor].peFlags = 0;
  581.         }
  583.         return m_pDD->CreatePalette( DDPCAPS_8BIT, aPalette, ppPalette, NULL );
  584.     }
  586.     // Attempt to load bitmap as a file
  587.     hFile = CreateFile( strBMP, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL );
  588.     if( NULL == hFile )
  589.         return E_FAIL;
  591.     // Read the BITMAPFILEHEADER
  592.     ReadFile( hFile, &bf, sizeof(bf), &dwBytesRead, NULL );
  593.     if( dwBytesRead != sizeof(bf) )
  594.     {
  595.         CloseHandle( hFile );
  596.         return E_FAIL;
  597.     }
  599.     // Read the BITMAPINFOHEADER
  600.     ReadFile( hFile, &bi, sizeof(bi), &dwBytesRead, NULL );
  601.     if( dwBytesRead != sizeof(bi) )
  602.     {
  603.         CloseHandle( hFile );
  604.         return E_FAIL;
  605.     }
  607.     // Read the PALETTEENTRY 
  608.     ReadFile( hFile, aPalette, sizeof(aPalette), &dwBytesRead, NULL );
  609.     if( dwBytesRead != sizeof(aPalette) )
  610.     {
  611.         CloseHandle( hFile );
  612.         return E_FAIL;
  613.     }
  615.     CloseHandle( hFile );
  617.     // Figure out how many colors there are
  618.     if( bi.biSize != sizeof(BITMAPINFOHEADER) )
  619.         dwColors = 0;
  620.     else if (bi.biBitCount > 8)
  621.         dwColors = 0;
  622.     else if (bi.biClrUsed == 0)
  623.         dwColors = 1 << bi.biBitCount;
  624.     else
  625.         dwColors = bi.biClrUsed;
  627.     //  A DIB color table has its colors stored BGR not RGB
  628.     //  so flip them around since DirectDraw uses RGB
  629.     for( iColor = 0; iColor < dwColors; iColor++ )
  630.     {
  631.         BYTE r = aPalette[iColor].peRed;
  632.         aPalette[iColor].peRed  = aPalette[iColor].peBlue;
  633.         aPalette[iColor].peBlue = r;
  634.     }
  636.     return m_pDD->CreatePalette( DDPCAPS_8BIT, aPalette, ppPalette, NULL );
  637. }
  642. //-----------------------------------------------------------------------------
  643. // Name: 
  644. // Desc: 
  645. //-----------------------------------------------------------------------------
  646. HRESULT CDisplay::UpdateBounds()
  647. {
  648.     if( m_bWindowed )
  649.     {
  650.         GetClientRect( m_hWnd, &m_rcWindow );
  651.         ClientToScreen( m_hWnd, (POINT*)&m_rcWindow );
  652.         ClientToScreen( m_hWnd, (POINT*)&m_rcWindow+1 );
  653.     }
  654.     else
  655.     {
  656.         SetRect( &m_rcWindow, 0, 0, GetSystemMetrics(SM_CXSCREEN),
  657.                  GetSystemMetrics(SM_CYSCREEN) );
  658.     }
  660.     return S_OK;
  661. }
  667. //-----------------------------------------------------------------------------
  668. // Name: CDisplay::InitClipper
  669. // Desc: 
  670. //-----------------------------------------------------------------------------
  671. HRESULT CDisplay::InitClipper()
  672. {
  673.     LPDIRECTDRAWCLIPPER pClipper;
  674.     HRESULT hr;
  676.     // Create a clipper when using GDI to draw on the primary surface 
  677.     if( FAILED( hr = m_pDD->CreateClipper( 0, &pClipper, NULL ) ) )
  678.         return hr;
  680.     pClipper->SetHWnd( 0, m_hWnd );
  682.     if( FAILED( hr = m_pddsFrontBuffer->SetClipper( pClipper ) ) )
  683.         return hr;
  685.     // We can release the clipper now since g_pDDSPrimary 
  686.     // now maintains a ref count on the clipper
  687.     SAFE_RELEASE( pClipper );
  689.     return S_OK;
  690. }
  696. //-----------------------------------------------------------------------------
  697. // Name: 
  698. // Desc: 
  699. //-----------------------------------------------------------------------------
  700. CSurface::CSurface()
  701. {
  702.     m_pdds = NULL;
  703.     m_bColorKeyed = NULL;
  704. }
  709. //-----------------------------------------------------------------------------
  710. // Name: 
  711. // Desc: 
  712. //-----------------------------------------------------------------------------
  713. CSurface::~CSurface()
  714. {
  715.     SAFE_RELEASE( m_pdds );
  716. }
  721. //-----------------------------------------------------------------------------
  722. // Name: 
  723. // Desc: 
  724. //-----------------------------------------------------------------------------
  725. HRESULT CSurface::Create( LPDIRECTDRAWSURFACE7 pdds )
  726. {
  727.     m_pdds = pdds;
  729.     if( m_pdds )
  730.     {
  731.         m_pdds->AddRef();
  733.         // Get the DDSURFACEDESC structure for this surface
  734.         m_ddsd.dwSize = sizeof(m_ddsd);
  735.         m_pdds->GetSurfaceDesc( &m_ddsd );
  736.     }
  738.     return S_OK;
  739. }
  744. //-----------------------------------------------------------------------------
  745. // Name: 
  746. // Desc: 
  747. //-----------------------------------------------------------------------------
  748. HRESULT CSurface::Create( LPDIRECTDRAW7 pDD, DDSURFACEDESC2* pddsd )
  749. {
  750.     HRESULT hr;
  752.     // Create the DDraw surface
  753.     if( FAILED( hr = pDD->CreateSurface( pddsd, &m_pdds, NULL ) ) )
  754.         return hr;
  756.     // Prepare the DDSURFACEDESC structure
  757.     m_ddsd.dwSize = sizeof(m_ddsd);
  759.     // Get the DDSURFACEDESC structure for this surface
  760.     m_pdds->GetSurfaceDesc( &m_ddsd );
  762.     return S_OK;
  763. }
  768. //-----------------------------------------------------------------------------
  769. // Name: 
  770. // Desc: 
  771. //-----------------------------------------------------------------------------
  772. HRESULT CSurface::Destroy()
  773. {
  774.     SAFE_RELEASE( m_pdds );
  775.     return S_OK;
  776. }
  781. //-----------------------------------------------------------------------------
  782. // Name: CSurface::DrawBitmap()
  783. // Desc: Draws a bitmap over an entire DirectDrawSurface, stretching the 
  784. //       bitmap if nessasary
  785. //-----------------------------------------------------------------------------
  786. HRESULT CSurface::DrawBitmap( HBITMAP hBMP, 
  787.                               DWORD dwBMPOriginX, DWORD dwBMPOriginY, 
  788.                               DWORD dwBMPWidth, DWORD dwBMPHeight )
  789. {
  790.     HDC            hDCImage;
  791.     HDC            hDC;
  792.     BITMAP         bmp;
  793.     DDSURFACEDESC2 ddsd;
  794.     HRESULT        hr;
  796.     if( hBMP == NULL || m_pdds == NULL )
  797.         return E_INVALIDARG;
  799.     // Make sure this surface is restored.
  800.     if( FAILED( hr = m_pdds->Restore() ) )
  801.         return hr;
  803.     // Get the surface.description
  804.     ddsd.dwSize  = sizeof(ddsd);
  805.     m_pdds->GetSurfaceDesc( &ddsd );
  807.     if( ddsd.ddpfPixelFormat.dwFlags == DDPF_FOURCC )
  808.         return E_NOTIMPL;
  810.     // Select bitmap into a memoryDC so we can use it.
  811.     hDCImage = CreateCompatibleDC( NULL );
  812.     if( NULL == hDCImage )
  813.         return E_FAIL;
  815.     SelectObject( hDCImage, hBMP );
  817.     // Get size of the bitmap
  818.     GetObject( hBMP, sizeof(bmp), &bmp );
  820.     // Use the passed size, unless zero
  821.     dwBMPWidth  = ( dwBMPWidth  == 0 ) ? bmp.bmWidth  : dwBMPWidth;     
  822.     dwBMPHeight = ( dwBMPHeight == 0 ) ? bmp.bmHeight : dwBMPHeight;
  824.     // Stretch the bitmap to cover this surface
  825.     if( FAILED( hr = m_pdds->GetDC( &hDC ) ) )
  826.         return hr;
  828. /*
  829.     StretchBlt( hDC, 0, 0, 
  830.                 ddsd.dwWidth, ddsd.dwHeight, 
  831.                 hDCImage, dwBMPOriginX, dwBMPOriginY,
  832.                 dwBMPWidth, dwBMPHeight, SRCCOPY );
  833. */
  835. BitBlt(hDC,dwBMPOriginX,dwBMPOriginY,dwBMPWidth,dwBMPHeight, hDCImage,0,0, SRCCOPY);
  836. // BitBlt(hDC,0,0,0,0, hDCImage,0,0, SRCCOPY);
  837.     if( FAILED( hr = m_pdds->ReleaseDC( hDC ) ) )
  838.         return hr;
  840.     DeleteDC( hDCImage );
  842.     return S_OK;
  843. }
  848. //-----------------------------------------------------------------------------
  849. // Name: CSurface::DrawText()
  850. // Desc: Draws a text string on a DirectDraw surface using hFont or the default
  851. //       GDI font if hFont is NULL.  
  852. //-----------------------------------------------------------------------------
  853. HRESULT CSurface::DrawText( HFONT hFont, const TCHAR* strText, 
  854.                             DWORD dwOriginX, DWORD dwOriginY,
  855.                             COLORREF crBackground, COLORREF crForeground )
  856. {
  857.     HDC     hDC = NULL;
  858.     HRESULT hr;
  860.     if( m_pdds == NULL || strText == NULL )
  861.         return E_INVALIDARG;
  863.     // Make sure this surface is restored.
  864.     if( FAILED( hr = m_pdds->Restore() ) )
  865.         return hr;
  867.     if( FAILED( hr = m_pdds->GetDC( &hDC ) ) )
  868.         return hr;
  870.     // Set the background and foreground color
  871.     SetBkColor( hDC, crBackground );
  872.     SetTextColor( hDC, crForeground );
  874.     if( hFont )
  875.         SelectObject( hDC, hFont );
  877.     // Use GDI to draw the text on the surface
  878.     TextOut( hDC, dwOriginX, dwOriginY, strText, _tcslen(strText) );
  880.     if( FAILED( hr = m_pdds->ReleaseDC( hDC ) ) )
  881.         return hr;
  883.     return S_OK;
  884. }
  889. //-----------------------------------------------------------------------------
  890. // Name: CSurface::ReDrawBitmapOnSurface()
  891. // Desc: Load a bitmap from a file or resource into a DirectDraw surface.
  892. //       normaly used to re-load a surface after a restore.
  893. //-----------------------------------------------------------------------------
  894. HRESULT CSurface::DrawBitmap( TCHAR* strBMP, 
  895.                               DWORD dwDesiredWidth, DWORD dwDesiredHeight  )
  896. {
  897.     HBITMAP hBMP;
  898.     HRESULT hr;
  900.     if( m_pdds == NULL || strBMP == NULL )
  901.         return E_INVALIDARG;
  903.     //  Try to load the bitmap as a resource, if that fails, try it as a file
  904.     hBMP = (HBITMAP) LoadImage( GetModuleHandle(NULL), strBMP, 
  905.                                 IMAGE_BITMAP, dwDesiredWidth, dwDesiredHeight, 
  906.                                 LR_CREATEDIBSECTION );
  907.     if( hBMP == NULL )
  908.     {
  909.         hBMP = (HBITMAP) LoadImage( NULL, strBMP, IMAGE_BITMAP, 
  910.                                     dwDesiredWidth, dwDesiredHeight, 
  911.                                     LR_LOADFROMFILE | LR_CREATEDIBSECTION );
  912.         if( hBMP == NULL )
  913.             return E_FAIL;
  914.     }
  916.     // Draw the bitmap on this surface
  917.     if( FAILED( hr = DrawBitmap( hBMP, 0, 0, 0, 0 ) ) )
  918.     {
  919.         DeleteObject( hBMP );
  920.         return hr;
  921.     }
  923.     DeleteObject( hBMP );
  925.     return S_OK;
  926. }
  931. //-----------------------------------------------------------------------------
  932. // Name: 
  933. // Desc: 
  934. //-----------------------------------------------------------------------------
  935. HRESULT CSurface::SetColorKey( DWORD dwColorKey )
  936. {
  937.     if( NULL == m_pdds )
  938.         return E_POINTER;
  940.     m_bColorKeyed = TRUE;
  942.     DDCOLORKEY ddck;
  943.     ddck.dwColorSpaceLowValue  = ConvertGDIColor( dwColorKey );
  944.     ddck.dwColorSpaceHighValue = ConvertGDIColor( dwColorKey );
  945.     
  946.     return m_pdds->SetColorKey( DDCKEY_SRCBLT, &ddck );
  947. }
  953. //-----------------------------------------------------------------------------
  954. // Name: CSurface::ConvertGDIColor()
  955. // Desc: Converts a GDI color (0x00bbggrr) into the equivalent color on a 
  956. //       DirectDrawSurface using its pixel format.  
  957. //-----------------------------------------------------------------------------
  958. DWORD CSurface::ConvertGDIColor( COLORREF dwGDIColor )
  959. {
  960.     if( m_pdds == NULL )
  961.     return 0x00000000;
  963.     COLORREF       rgbT;
  964.     HDC            hdc;
  965.     DWORD          dw = CLR_INVALID;
  966.     DDSURFACEDESC2 ddsd;
  967.     HRESULT        hr;
  969.     //  Use GDI SetPixel to color match for us
  970.     if( dwGDIColor != CLR_INVALID && m_pdds->GetDC(&hdc) == DD_OK)
  971.     {
  972.         rgbT = GetPixel(hdc, 0, 0);     // Save current pixel value
  973.         SetPixel(hdc, 0, 0, dwGDIColor);       // Set our value
  974.         m_pdds->ReleaseDC(hdc);
  975.     }
  977.     // Now lock the surface so we can read back the converted color
  978.     ddsd.dwSize = sizeof(ddsd);
  979.     hr = m_pdds->Lock( NULL, &ddsd, DDLOCK_WAIT, NULL );
  980.     if( hr == DD_OK)
  981.     {
  982.         dw = *(DWORD *) ddsd.lpSurface; 
  983.         if( ddsd.ddpfPixelFormat.dwRGBBitCount < 32 ) // Mask it to bpp
  984.             dw &= ( 1 << ddsd.ddpfPixelFormat.dwRGBBitCount ) - 1;  
  985.         m_pdds->Unlock(NULL);
  986.     }
  988.     //  Now put the color that was there back.
  989.     if( dwGDIColor != CLR_INVALID && m_pdds->GetDC(&hdc) == DD_OK )
  990.     {
  991.         SetPixel( hdc, 0, 0, rgbT );
  992.         m_pdds->ReleaseDC(hdc);
  993.     }
  994.     
  995.     return dw;    
  996. }
  1001. //-----------------------------------------------------------------------------
  1002. // Name: CSurface::GetBitMaskInfo()
  1003. // Desc: Returns the number of bits and the shift in the bit mask
  1004. //-----------------------------------------------------------------------------
  1005. HRESULT CSurface::GetBitMaskInfo( DWORD dwBitMask, DWORD* pdwShift, DWORD* pdwBits )
  1006. {
  1007.     DWORD dwShift = 0;
  1008.     DWORD dwBits  = 0; 
  1010.     if( pdwShift == NULL || pdwBits == NULL )
  1011.         return E_INVALIDARG;
  1013.     if( dwBitMask )
  1014.     {
  1015.         while( (dwBitMask & 1) == 0 )
  1016.         {
  1017.             dwShift++;
  1018.             dwBitMask >>= 1;
  1019.         }
  1020.     }
  1022.     while( (dwBitMask & 1) != 0 )
  1023.     {
  1024.         dwBits++;
  1025.         dwBitMask >>= 1;
  1026.     }
  1028.     *pdwShift = dwShift;
  1029.     *pdwBits  = dwBits;
  1031.     return S_OK;
  1032. }
  1038. HRESULT CSurface::Clear(DWORD dwColor)
  1039. {
  1040.     if( NULL == m_pdds )
  1041.         return E_POINTER;
  1043.     // Erase the background
  1044.     DDBLTFX ddbltfx;
  1045.     ZeroMemory( &ddbltfx, sizeof(ddbltfx) );
  1046.     ddbltfx.dwSize      = sizeof(ddbltfx);
  1047.     ddbltfx.dwFillColor = dwColor;
  1049.     return m_pdds->Blt( NULL, NULL, NULL, DDBLT_COLORFILL, &ddbltfx );
  1050. }
  1052. const DDSURFACEDESC2& CSurface::GetSurfaceDesc() const
  1053. {
  1054. return m_ddsd;
  1055. }
  1057. HRESULT CSurface::DrawRect(RECT rcRect, COLORREF crForeground )
  1058. {
  1059.     HDC     hDC = NULL;
  1060.     HRESULT hr;
  1062.     if( m_pdds == NULL )
  1063.         return E_INVALIDARG;
  1065.     // Make sure this surface is restored.
  1066.     if( FAILED( hr = m_pdds->Restore() ) )
  1067.         return hr;
  1069.     if( FAILED( hr = m_pdds->GetDC( &hDC ) ) )
  1070.         return hr;
  1072. HPEN hPen= CreatePen(PS_SOLID,    // pen style
  1073.                    0,        // pen width
  1074.                    crForeground   // pen color
  1075.     );
  1076. HPEN hOldPen=(HPEN)SelectObject(hDC,(HGDIOBJ)hPen);
  1078.     // Use GDI to draw the rectangle
  1079.     DrawEdge(hDC, &rcRect, EDGE_ETCHED, BF_RECT);
  1081.     if( FAILED( hr = m_pdds->ReleaseDC( hDC ) ) )
  1082.         return hr;
  1084. SelectObject(hDC,(HGDIOBJ) hOldPen);
  1085. DeleteObject(hPen);
  1086.     return S_OK;
  1088. }
  1090. HRESULT CSurface::DrawLine(POINT p1, POINT p2, COLORREF crForeground)
  1091. {
  1092.     HDC     hDC = NULL;
  1093.     HRESULT hr;
  1095.     if( m_pdds == NULL )
  1096.         return E_INVALIDARG;
  1098.     // Make sure this surface is restored.
  1099.     if( FAILED( hr = m_pdds->Restore() ) )
  1100.         return hr;
  1102.     if( FAILED( hr = m_pdds->GetDC( &hDC ) ) )
  1103.         return hr;
  1105. HPEN hPen= CreatePen(PS_SOLID,    // pen style
  1106.                    0,        // pen width
  1107.                    crForeground   // pen color
  1108.     );
  1109. HPEN hOldPen=(HPEN)SelectObject(hDC,(HGDIOBJ)hPen);
  1111.     // Use GDI to draw the line
  1112.     MoveToEx(hDC, p1.x, p1.y, NULL);
  1113. LineTo(hDC, p2.x, p2.y);
  1114.     if( FAILED( hr = m_pdds->ReleaseDC( hDC ) ) )
  1115.         return hr;
  1117. SelectObject(hDC,(HGDIOBJ) hOldPen);
  1118. DeleteObject(hPen);
  1119.     return S_OK;
  1120. }