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

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

游戏

开发平台：

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. // Copyright (c) Microsoft Corporation. All rights reserved.
  8. //-----------------------------------------------------------------------------
  9. #define STRICT
  10. #include <tchar.h>
  11. #include <windows.h>
  12. #include <windowsx.h>
  13. #include <ddraw.h>
  14. #include "ddutil.h"
  15. #include "dxutil.h"
  22. //-----------------------------------------------------------------------------
  23. // Name: CDisplay()
  24. // Desc:
  25. //-----------------------------------------------------------------------------
  26. CDisplay::CDisplay()
  27. {
  28.     m_pDD                = NULL;
  29.     m_pddsFrontBuffer    = NULL;
  30.     m_pddsBackBuffer     = NULL;
  31.     m_pddsBackBufferLeft = NULL;
  32. }
  37. //-----------------------------------------------------------------------------
  38. // Name: ~CDisplay()
  39. // Desc:
  40. //-----------------------------------------------------------------------------
  41. CDisplay::~CDisplay()
  42. {
  43.     DestroyObjects();
  44. }
  49. //-----------------------------------------------------------------------------
  50. // Name: DestroyObjects()
  51. // Desc:
  52. //-----------------------------------------------------------------------------
  53. HRESULT CDisplay::DestroyObjects()
  54. {
  55.     SAFE_RELEASE( m_pddsBackBufferLeft );
  56.     SAFE_RELEASE( m_pddsBackBuffer );
  57.     SAFE_RELEASE( m_pddsFrontBuffer );
  59.     if( m_pDD )
  60.         m_pDD->SetCooperativeLevel( m_hWnd, DDSCL_NORMAL );
  62.     SAFE_RELEASE( m_pDD );
  64.     return S_OK;
  65. }
  70. //-----------------------------------------------------------------------------
  71. // Name: CreateFullScreenDisplay()
  72. // Desc:
  73. //-----------------------------------------------------------------------------
  74. HRESULT CDisplay::CreateFullScreenDisplay( HWND hWnd, DWORD dwWidth,
  75.                                            DWORD dwHeight, DWORD dwBPP )
  76. {
  77.     HRESULT hr;
  79.     // Cleanup anything from a previous call
  80.     DestroyObjects();
  82.     // DDraw stuff begins here
  83.     if( FAILED( hr = DirectDrawCreateEx( NULL, (VOID**)&m_pDD,
  84.                                          IID_IDirectDraw7, NULL ) ) )
  85.         return E_FAIL;
  87.     // Set cooperative level
  88.     hr = m_pDD->SetCooperativeLevel( hWnd, DDSCL_EXCLUSIVE|DDSCL_FULLSCREEN );
  89.     if( FAILED(hr) )
  90.         return E_FAIL;
  92.     // Set the display mode
  93.     if( FAILED( m_pDD->SetDisplayMode( dwWidth, dwHeight, dwBPP, 0, 0 ) ) )
  94.         return E_FAIL;
  96.     // Create primary surface (with backbuffer attached)
  97.     DDSURFACEDESC2 ddsd;
  98.     ZeroMemory( &ddsd, sizeof( ddsd ) );
  99.     ddsd.dwSize            = sizeof( ddsd );
  100.     ddsd.dwFlags           = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
  101.     ddsd.ddsCaps.dwCaps    = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP |
  102.                              DDSCAPS_COMPLEX | DDSCAPS_3DDEVICE;
  103.     ddsd.dwBackBufferCount = 1;
  105.     if( FAILED( hr = m_pDD->CreateSurface( &ddsd, &m_pddsFrontBuffer,
  106.                                            NULL ) ) )
  107.         return E_FAIL;
  109.     // Get a pointer to the back buffer
  110.     DDSCAPS2 ddscaps;
  111.     ZeroMemory( &ddscaps, sizeof( ddscaps ) );
  112.     ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
  114.     if( FAILED( hr = m_pddsFrontBuffer->GetAttachedSurface( &ddscaps,
  115.                                                             &m_pddsBackBuffer ) ) )
  116.         return E_FAIL;
  118.     m_pddsBackBuffer->AddRef();
  120.     m_hWnd      = hWnd;
  121.     m_bWindowed = FALSE;
  122.     UpdateBounds();
  124.     return S_OK;
  125. }
  126.     
  130. //-----------------------------------------------------------------------------
  131. // Name: CreateWindowedDisplay()
  132. // Desc:
  133. //-----------------------------------------------------------------------------
  134. HRESULT CDisplay::CreateWindowedDisplay( HWND hWnd, DWORD dwWidth, DWORD dwHeight )
  135. {
  136.     HRESULT hr;
  138.     // Cleanup anything from a previous call
  139.     DestroyObjects();
  141.     // DDraw stuff begins here
  142.     if( FAILED( hr = DirectDrawCreateEx( NULL, (VOID**)&m_pDD,
  143.                                          IID_IDirectDraw7, NULL ) ) )
  144.         return E_FAIL;
  146.     // Set cooperative level
  147.     hr = m_pDD->SetCooperativeLevel( hWnd, DDSCL_NORMAL );
  148.     if( FAILED(hr) )
  149.         return E_FAIL;
  151.     RECT  rcWork;
  152.     RECT  rc;
  153.     DWORD dwStyle;
  155.     // If we are still a WS_POPUP window we should convert to a normal app
  156.     // window so we look like a windows app.
  157.     dwStyle  = GetWindowStyle( hWnd );
  158.     dwStyle &= ~WS_POPUP;
  159.     dwStyle |= WS_OVERLAPPED | WS_CAPTION | WS_THICKFRAME | WS_MINIMIZEBOX;
  160.     SetWindowLong( hWnd, GWL_STYLE, dwStyle );
  162.     // Aet window size
  163.     SetRect( &rc, 0, 0, dwWidth, dwHeight );
  165.     AdjustWindowRectEx( &rc, GetWindowStyle(hWnd), GetMenu(hWnd) != NULL,
  166.                         GetWindowExStyle(hWnd) );
  168.     SetWindowPos( hWnd, NULL, 0, 0, rc.right-rc.left, rc.bottom-rc.top,
  169.                   SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE );
  171.     SetWindowPos( hWnd, HWND_NOTOPMOST, 0, 0, 0, 0,
  172.                   SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE );
  174.     //  Make sure our window does not hang outside of the work area
  175.     SystemParametersInfo( SPI_GETWORKAREA, 0, &rcWork, 0 );
  176.     GetWindowRect( hWnd, &rc );
  177.     if( rc.left < rcWork.left ) rc.left = rcWork.left;
  178.     if( rc.top  < rcWork.top )  rc.top  = rcWork.top;
  179.     SetWindowPos( hWnd, NULL, rc.left, rc.top, 0, 0,
  180.                   SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE );
  182.     LPDIRECTDRAWCLIPPER pcClipper;
  183.     
  184.     // Create the primary surface
  185.     DDSURFACEDESC2 ddsd;
  186.     ZeroMemory( &ddsd, sizeof( ddsd ) );
  187.     ddsd.dwSize         = sizeof( ddsd );
  188.     ddsd.dwFlags        = DDSD_CAPS;
  189.     ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
  191.     if( FAILED( m_pDD->CreateSurface( &ddsd, &m_pddsFrontBuffer, NULL ) ) )
  192.         return E_FAIL;
  194.     // Create the backbuffer surface
  195.     ddsd.dwFlags        = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;    
  196.     ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE;
  197.     ddsd.dwWidth        = dwWidth;
  198.     ddsd.dwHeight       = dwHeight;
  200.     if( FAILED( hr = m_pDD->CreateSurface( &ddsd, &m_pddsBackBuffer, NULL ) ) )
  201.         return E_FAIL;
  203.     if( FAILED( hr = m_pDD->CreateClipper( 0, &pcClipper, NULL ) ) )
  204.         return E_FAIL;
  206.     if( FAILED( hr = pcClipper->SetHWnd( 0, hWnd ) ) )
  207.     {
  208.         pcClipper->Release();
  209.         return E_FAIL;
  210.     }
  212.     if( FAILED( hr = m_pddsFrontBuffer->SetClipper( pcClipper ) ) )
  213.     {
  214.         pcClipper->Release();
  215.         return E_FAIL;
  216.     }
  218.     // Done with clipper
  219.     pcClipper->Release();
  221.     m_hWnd      = hWnd;
  222.     m_bWindowed = TRUE;
  223.     UpdateBounds();
  225.     return S_OK;
  226. }
  231. //-----------------------------------------------------------------------------
  232. // Name: 
  233. // Desc: 
  234. //-----------------------------------------------------------------------------
  235. HRESULT CDisplay::CreateSurface( CSurface** ppSurface,
  236.                                  DWORD dwWidth, DWORD dwHeight )
  237. {
  238.     if( NULL == m_pDD )
  239.         return E_POINTER;
  240.     if( NULL == ppSurface )
  241.         return E_INVALIDARG;
  243.     HRESULT        hr;
  244.     DDSURFACEDESC2 ddsd;
  245.     ZeroMemory( &ddsd, sizeof( ddsd ) );
  246.     ddsd.dwSize         = sizeof( ddsd );
  247.     ddsd.dwFlags        = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; 
  248.     ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
  249.     ddsd.dwWidth        = dwWidth;
  250.     ddsd.dwHeight       = dwHeight;
  252.     (*ppSurface) = new CSurface();
  253.     if( FAILED( hr = (*ppSurface)->Create( m_pDD, &ddsd ) ) )
  254.     {
  255.         delete (*ppSurface);
  256.         return hr;
  257.     }
  259.     return S_OK;
  260. }
  265. //-----------------------------------------------------------------------------
  266. // Name: CDisplay::CreateSurfaceFromBitmap()
  267. // Desc: Create a DirectDrawSurface from a bitmap resource or bitmap file.
  268. //       Use MAKEINTRESOURCE() to pass a constant into strBMP.
  269. //-----------------------------------------------------------------------------
  270. HRESULT CDisplay::CreateSurfaceFromBitmap( CSurface** ppSurface,
  271.                                            TCHAR* strBMP,                                            
  272.                                            DWORD dwDesiredWidth, 
  273.                                            DWORD dwDesiredHeight )
  274. {
  275.     HRESULT        hr;
  276.     HBITMAP        hBMP = NULL;
  277.     BITMAP         bmp;
  278.     DDSURFACEDESC2 ddsd;
  280.     if( m_pDD == NULL || strBMP == NULL || ppSurface == NULL ) 
  281.         return E_INVALIDARG;
  283.     *ppSurface = NULL;
  285.     //  Try to load the bitmap as a resource, if that fails, try it as a file
  286.     hBMP = (HBITMAP) LoadImage( GetModuleHandle(NULL), strBMP, 
  287.                                 IMAGE_BITMAP, dwDesiredWidth, dwDesiredHeight, 
  288.                                 LR_CREATEDIBSECTION );
  289.     if( hBMP == NULL )
  290.     {
  291.         hBMP = (HBITMAP) LoadImage( NULL, strBMP, 
  292.                                     IMAGE_BITMAP, dwDesiredWidth, dwDesiredHeight, 
  293.                                     LR_LOADFROMFILE | LR_CREATEDIBSECTION );
  294.         if( hBMP == NULL )
  295.             return E_FAIL;
  296.     }
  298.     // Get size of the bitmap
  299.     GetObject( hBMP, sizeof(bmp), &bmp );
  301.     // Create a DirectDrawSurface for this bitmap
  302.     ZeroMemory( &ddsd, sizeof(ddsd) );
  303.     ddsd.dwSize         = sizeof(ddsd);
  304.     ddsd.dwFlags        = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
  305.     ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
  306.     ddsd.dwWidth        = bmp.bmWidth;
  307.     ddsd.dwHeight       = bmp.bmHeight;
  309.     (*ppSurface) = new CSurface();
  310.     if( FAILED( hr = (*ppSurface)->Create( m_pDD, &ddsd ) ) )
  311.     {
  312.         delete (*ppSurface);
  313.         return hr;
  314.     }
  316.     // Draw the bitmap on this surface
  317.     if( FAILED( hr = (*ppSurface)->DrawBitmap( hBMP, 0, 0, 0, 0 ) ) )
  318.     {
  319.         DeleteObject( hBMP );
  320.         return hr;
  321.     }
  323.     DeleteObject( hBMP );
  325.     return S_OK;
  326. }
  331. //-----------------------------------------------------------------------------
  332. // Name: CDisplay::CreateSurfaceFromText()
  333. // Desc: Creates a DirectDrawSurface from a text string using hFont or the default 
  334. //       GDI font if hFont is NULL.
  335. //-----------------------------------------------------------------------------
  336. HRESULT CDisplay::CreateSurfaceFromText( CSurface** ppSurface,
  337.                                          HFONT hFont, TCHAR* strText, 
  338.                                          COLORREF crBackground, COLORREF crForeground )
  339. {
  340.     HDC                  hDC  = NULL;
  341.     LPDIRECTDRAWSURFACE7 pDDS = NULL;
  342.     HRESULT              hr;
  343.     DDSURFACEDESC2       ddsd;
  344.     SIZE                 sizeText;
  346.     if( m_pDD == NULL || strText == NULL || ppSurface == NULL )
  347.         return E_INVALIDARG;
  349.     *ppSurface = NULL;
  351.     hDC = GetDC( NULL );
  353.     if( hFont )
  354.         SelectObject( hDC, hFont );
  356.     GetTextExtentPoint32( hDC, strText, _tcslen(strText), &sizeText );
  357.     ReleaseDC( NULL, hDC );
  359.     // Create a DirectDrawSurface for this bitmap
  360.     ZeroMemory( &ddsd, sizeof(ddsd) );
  361.     ddsd.dwSize         = sizeof(ddsd);
  362.     ddsd.dwFlags        = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
  363.     ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
  364.     ddsd.dwWidth        = sizeText.cx;
  365.     ddsd.dwHeight       = sizeText.cy;
  367.     (*ppSurface) = new CSurface();
  368.     if( FAILED( hr = (*ppSurface)->Create( m_pDD, &ddsd ) ) )
  369.     {
  370.         delete (*ppSurface);
  371.         return hr;
  372.     }
  374.     if( FAILED( hr = (*ppSurface)->DrawText( hFont, strText, 0, 0, 
  375.                                              crBackground, crForeground ) ) )
  376.         return hr;
  378.     return S_OK;
  379. }
  384. //-----------------------------------------------------------------------------
  385. // Name: 
  386. // Desc: 
  387. //-----------------------------------------------------------------------------
  388. HRESULT CDisplay::Present()
  389. {
  390.     HRESULT hr;
  392.     if( NULL == m_pddsFrontBuffer && NULL == m_pddsBackBuffer )
  393.         return E_POINTER;
  395.     while( 1 )
  396.     {
  397.         if( m_bWindowed )
  398.             hr = m_pddsFrontBuffer->Blt( &m_rcWindow, m_pddsBackBuffer,
  399.                                          NULL, DDBLT_WAIT, NULL );
  400.         else
  401.             hr = m_pddsFrontBuffer->Flip( NULL, 0 );
  403.         if( hr == DDERR_SURFACELOST )
  404.         {
  405.             m_pddsFrontBuffer->Restore();
  406.             m_pddsBackBuffer->Restore();
  407.         }
  409.         if( hr != DDERR_WASSTILLDRAWING )
  410.             return hr;
  411.     }
  412. }
  417. //-----------------------------------------------------------------------------
  418. // Name: 
  419. // Desc: 
  420. //-----------------------------------------------------------------------------
  421. HRESULT CDisplay::ShowBitmap( HBITMAP hbm, LPDIRECTDRAWPALETTE pPalette )
  422. {
  423.     if( NULL == m_pddsFrontBuffer ||  NULL == m_pddsBackBuffer )
  424.         return E_POINTER;
  426.     // Set the palette before loading the bitmap
  427.     if( pPalette )
  428.         m_pddsFrontBuffer->SetPalette( pPalette );
  430.     CSurface backBuffer;
  431.     backBuffer.Create( m_pddsBackBuffer );
  433.     if( FAILED( backBuffer.DrawBitmap( hbm, 0, 0, 0, 0 ) ) )
  434.         return E_FAIL;
  436.     return Present();
  437. }
  442. //-----------------------------------------------------------------------------
  443. // Name: 
  444. // Desc: 
  445. //-----------------------------------------------------------------------------
  446. HRESULT CDisplay::ColorKeyBlt( DWORD x, DWORD y, LPDIRECTDRAWSURFACE7 pdds,
  447.                                RECT* prc )
  448. {
  449.     if( NULL == m_pddsBackBuffer )
  450.         return E_POINTER;
  452.     return m_pddsBackBuffer->BltFast( x, y, pdds, prc, DDBLTFAST_SRCCOLORKEY );
  453. }
  458. //-----------------------------------------------------------------------------
  459. // Name: 
  460. // Desc: 
  461. //-----------------------------------------------------------------------------
  462. HRESULT CDisplay::Blt( DWORD x, DWORD y, LPDIRECTDRAWSURFACE7 pdds, RECT* prc,
  463.                        DWORD dwFlags )
  464. {
  465.     if( NULL == m_pddsBackBuffer )
  466.         return E_POINTER;
  468.     return m_pddsBackBuffer->BltFast( x, y, pdds, prc, dwFlags );
  469. }
  474. //-----------------------------------------------------------------------------
  475. // Name: 
  476. // Desc: 
  477. //-----------------------------------------------------------------------------
  478. HRESULT CDisplay::Blt( DWORD x, DWORD y, CSurface* pSurface, RECT* prc )
  479. {
  480.     if( NULL == pSurface )
  481.         return E_INVALIDARG;
  483.     if( pSurface->IsColorKeyed() )
  484.         return Blt( x, y, pSurface->GetDDrawSurface(), prc, DDBLTFAST_SRCCOLORKEY );
  485.     else
  486.         return Blt( x, y, pSurface->GetDDrawSurface(), prc, 0L );
  487. }
  492. //-----------------------------------------------------------------------------
  493. // Name: 
  494. // Desc: 
  495. //-----------------------------------------------------------------------------
  496. HRESULT CDisplay::Clear( DWORD dwColor )
  497. {
  498.     if( NULL == m_pddsBackBuffer )
  499.         return E_POINTER;
  501.     // Erase the background
  502.     DDBLTFX ddbltfx;
  503.     ZeroMemory( &ddbltfx, sizeof(ddbltfx) );
  504.     ddbltfx.dwSize      = sizeof(ddbltfx);
  505.     ddbltfx.dwFillColor = dwColor;
  507.     return m_pddsBackBuffer->Blt( NULL, NULL, NULL, DDBLT_COLORFILL, &ddbltfx );
  508. }
  513. //-----------------------------------------------------------------------------
  514. // Name: 
  515. // Desc: 
  516. //-----------------------------------------------------------------------------
  517. HRESULT CDisplay::SetPalette( LPDIRECTDRAWPALETTE pPalette )
  518. {
  519.     if( NULL == m_pddsFrontBuffer )
  520.         return E_POINTER;
  522.     return m_pddsFrontBuffer->SetPalette( pPalette );
  523. }
  528. //-----------------------------------------------------------------------------
  529. // Name: 
  530. // Desc: 
  531. //-----------------------------------------------------------------------------
  532. HRESULT CDisplay::CreatePaletteFromBitmap( LPDIRECTDRAWPALETTE* ppPalette,
  533.                                            const TCHAR* strBMP )
  534. {
  535.     HRSRC             hResource      = NULL;
  536.     RGBQUAD*          pRGB           = NULL;
  537.     BITMAPINFOHEADER* pbi = NULL;
  538.     PALETTEENTRY      aPalette[256];
  539.     HANDLE            hFile = NULL;
  540.     DWORD             iColor;
  541.     DWORD             dwColors;
  542.     BITMAPFILEHEADER  bf;
  543.     BITMAPINFOHEADER  bi;
  544.     DWORD             dwBytesRead;
  546.     if( m_pDD == NULL || strBMP == NULL || ppPalette == NULL )
  547.         return E_INVALIDARG;
  549.     *ppPalette = NULL;
  551.     //  Try to load the bitmap as a resource, if that fails, try it as a file
  552.     hResource = FindResource( NULL, strBMP, RT_BITMAP );
  553.     if( hResource )
  554.     {
  555.         pbi = (LPBITMAPINFOHEADER) LockResource( LoadResource( NULL, hResource ) );       
  556.         if( NULL == pbi )
  557.             return E_FAIL;
  559.         pRGB = (RGBQUAD*) ( (BYTE*) pbi + pbi->biSize );
  561.         // Figure out how many colors there are
  562.         if( pbi == NULL || pbi->biSize < sizeof(BITMAPINFOHEADER) )
  563.             dwColors = 0;
  564.         else if( pbi->biBitCount > 8 )
  565.             dwColors = 0;
  566.         else if( pbi->biClrUsed == 0 )
  567.             dwColors = 1 << pbi->biBitCount;
  568.         else
  569.             dwColors = pbi->biClrUsed;
  571.         //  A DIB color table has its colors stored BGR not RGB
  572.         //  so flip them around.
  573.         for( iColor = 0; iColor < dwColors; iColor++ )
  574.         {
  575.             aPalette[iColor].peRed   = pRGB[iColor].rgbRed;
  576.             aPalette[iColor].peGreen = pRGB[iColor].rgbGreen;
  577.             aPalette[iColor].peBlue  = pRGB[iColor].rgbBlue;
  578.             aPalette[iColor].peFlags = 0;
  579.         }
  581.         return m_pDD->CreatePalette( DDPCAPS_8BIT, aPalette, ppPalette, NULL );
  582.     }
  584.     // Attempt to load bitmap as a file
  585.     hFile = CreateFile( strBMP, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL );
  586.     if( INVALID_HANDLE_VALUE == hFile )
  587.         return E_FAIL;
  589.     // Read the BITMAPFILEHEADER
  590.     ReadFile( hFile, &bf, sizeof(bf), &dwBytesRead, NULL );
  591.     if( dwBytesRead != sizeof(bf) )
  592.     {
  593.         CloseHandle( hFile );
  594.         return E_FAIL;
  595.     }
  597.     // Read the BITMAPINFOHEADER
  598.     ReadFile( hFile, &bi, sizeof(bi), &dwBytesRead, NULL );
  599.     if( dwBytesRead != sizeof(bi) )
  600.     {
  601.         CloseHandle( hFile );
  602.         return E_FAIL;
  603.     }
  605.     // Read the PALETTEENTRY 
  606.     ReadFile( hFile, aPalette, sizeof(aPalette), &dwBytesRead, NULL );
  607.     if( dwBytesRead != sizeof(aPalette) )
  608.     {
  609.         CloseHandle( hFile );
  610.         return E_FAIL;
  611.     }
  613.     CloseHandle( hFile );
  615.     // Figure out how many colors there are
  616.     if( bi.biSize != sizeof(BITMAPINFOHEADER) )
  617.         dwColors = 0;
  618.     else if (bi.biBitCount > 8)
  619.         dwColors = 0;
  620.     else if (bi.biClrUsed == 0)
  621.         dwColors = 1 << bi.biBitCount;
  622.     else
  623.         dwColors = bi.biClrUsed;
  625.     //  A DIB color table has its colors stored BGR not RGB
  626.     //  so flip them around since DirectDraw uses RGB
  627.     for( iColor = 0; iColor < dwColors; iColor++ )
  628.     {
  629.         BYTE r = aPalette[iColor].peRed;
  630.         aPalette[iColor].peRed  = aPalette[iColor].peBlue;
  631.         aPalette[iColor].peBlue = r;
  632.     }
  634.     return m_pDD->CreatePalette( DDPCAPS_8BIT, aPalette, ppPalette, NULL );
  635. }
  640. //-----------------------------------------------------------------------------
  641. // Name: 
  642. // Desc: 
  643. //-----------------------------------------------------------------------------
  644. HRESULT CDisplay::UpdateBounds()
  645. {
  646.     if( m_bWindowed )
  647.     {
  648.         GetClientRect( m_hWnd, &m_rcWindow );
  649.         ClientToScreen( m_hWnd, (POINT*)&m_rcWindow );
  650.         ClientToScreen( m_hWnd, (POINT*)&m_rcWindow+1 );
  651.     }
  652.     else
  653.     {
  654.         SetRect( &m_rcWindow, 0, 0, GetSystemMetrics(SM_CXSCREEN),
  655.                  GetSystemMetrics(SM_CYSCREEN) );
  656.     }
  658.     return S_OK;
  659. }
  665. //-----------------------------------------------------------------------------
  666. // Name: CDisplay::InitClipper
  667. // Desc: 
  668. //-----------------------------------------------------------------------------
  669. HRESULT CDisplay::InitClipper()
  670. {
  671.     LPDIRECTDRAWCLIPPER pClipper;
  672.     HRESULT hr;
  674.     // Create a clipper when using GDI to draw on the primary surface 
  675.     if( FAILED( hr = m_pDD->CreateClipper( 0, &pClipper, NULL ) ) )
  676.         return hr;
  678.     pClipper->SetHWnd( 0, m_hWnd );
  680.     if( FAILED( hr = m_pddsFrontBuffer->SetClipper( pClipper ) ) )
  681.         return hr;
  683.     // We can release the clipper now since g_pDDSPrimary 
  684.     // now maintains a ref count on the clipper
  685.     SAFE_RELEASE( pClipper );
  687.     return S_OK;
  688. }
  694. //-----------------------------------------------------------------------------
  695. // Name: 
  696. // Desc: 
  697. //-----------------------------------------------------------------------------
  698. CSurface::CSurface()
  699. {
  700.     m_pdds = NULL;
  701.     m_bColorKeyed = NULL;
  702. }
  707. //-----------------------------------------------------------------------------
  708. // Name: 
  709. // Desc: 
  710. //-----------------------------------------------------------------------------
  711. CSurface::~CSurface()
  712. {
  713.     SAFE_RELEASE( m_pdds );
  714. }
  719. //-----------------------------------------------------------------------------
  720. // Name: 
  721. // Desc: 
  722. //-----------------------------------------------------------------------------
  723. HRESULT CSurface::Create( LPDIRECTDRAWSURFACE7 pdds )
  724. {
  725.     m_pdds = pdds;
  727.     if( m_pdds )
  728.     {
  729.         m_pdds->AddRef();
  731.         // Get the DDSURFACEDESC structure for this surface
  732.         m_ddsd.dwSize = sizeof(m_ddsd);
  733.         m_pdds->GetSurfaceDesc( &m_ddsd );
  734.     }
  736.     return S_OK;
  737. }
  742. //-----------------------------------------------------------------------------
  743. // Name: 
  744. // Desc: 
  745. //-----------------------------------------------------------------------------
  746. HRESULT CSurface::Create( LPDIRECTDRAW7 pDD, DDSURFACEDESC2* pddsd )
  747. {
  748.     HRESULT hr;
  750.     // Create the DDraw surface
  751.     if( FAILED( hr = pDD->CreateSurface( pddsd, &m_pdds, NULL ) ) )
  752.         return hr;
  754.     // Prepare the DDSURFACEDESC structure
  755.     m_ddsd.dwSize = sizeof(m_ddsd);
  757.     // Get the DDSURFACEDESC structure for this surface
  758.     m_pdds->GetSurfaceDesc( &m_ddsd );
  760.     return S_OK;
  761. }
  766. //-----------------------------------------------------------------------------
  767. // Name: 
  768. // Desc: 
  769. //-----------------------------------------------------------------------------
  770. HRESULT CSurface::Destroy()
  771. {
  772.     SAFE_RELEASE( m_pdds );
  773.     return S_OK;
  774. }
  779. //-----------------------------------------------------------------------------
  780. // Name: CSurface::DrawBitmap()
  781. // Desc: Draws a bitmap over an entire DirectDrawSurface, stretching the 
  782. //       bitmap if nessasary
  783. //-----------------------------------------------------------------------------
  784. HRESULT CSurface::DrawBitmap( HBITMAP hBMP, 
  785.                               DWORD dwBMPOriginX, DWORD dwBMPOriginY, 
  786.                               DWORD dwBMPWidth, DWORD dwBMPHeight )
  787. {
  788.     HDC            hDCImage;
  789.     HDC            hDC;
  790.     BITMAP         bmp;
  791.     DDSURFACEDESC2 ddsd;
  792.     HRESULT        hr;
  794.     if( hBMP == NULL || m_pdds == NULL )
  795.         return E_INVALIDARG;
  797.     // Make sure this surface is restored.
  798.     if( FAILED( hr = m_pdds->Restore() ) )
  799.         return hr;
  801.     // Get the surface.description
  802.     ddsd.dwSize  = sizeof(ddsd);
  803.     m_pdds->GetSurfaceDesc( &ddsd );
  805.     if( ddsd.ddpfPixelFormat.dwFlags == DDPF_FOURCC )
  806.         return E_NOTIMPL;
  808.     // Select bitmap into a memoryDC so we can use it.
  809.     hDCImage = CreateCompatibleDC( NULL );
  810.     if( NULL == hDCImage )
  811.         return E_FAIL;
  813.     SelectObject( hDCImage, hBMP );
  815.     // Get size of the bitmap
  816.     GetObject( hBMP, sizeof(bmp), &bmp );
  818.     // Use the passed size, unless zero
  819.     dwBMPWidth  = ( dwBMPWidth  == 0 ) ? bmp.bmWidth  : dwBMPWidth;     
  820.     dwBMPHeight = ( dwBMPHeight == 0 ) ? bmp.bmHeight : dwBMPHeight;
  822.     // Stretch the bitmap to cover this surface
  823.     if( FAILED( hr = m_pdds->GetDC( &hDC ) ) )
  824.         return hr;
  826.     StretchBlt( hDC, 0, 0, 
  827.                 ddsd.dwWidth, ddsd.dwHeight, 
  828.                 hDCImage, dwBMPOriginX, dwBMPOriginY,
  829.                 dwBMPWidth, dwBMPHeight, SRCCOPY );
  831.     if( FAILED( hr = m_pdds->ReleaseDC( hDC ) ) )
  832.         return hr;
  834.     DeleteDC( hDCImage );
  836.     return S_OK;
  837. }
  842. //-----------------------------------------------------------------------------
  843. // Name: CSurface::DrawText()
  844. // Desc: Draws a text string on a DirectDraw surface using hFont or the default
  845. //       GDI font if hFont is NULL.  
  846. //-----------------------------------------------------------------------------
  847. HRESULT CSurface::DrawText( HFONT hFont, TCHAR* strText, 
  848.                             DWORD dwOriginX, DWORD dwOriginY,
  849.                             COLORREF crBackground, COLORREF crForeground )
  850. {
  851.     HDC     hDC = NULL;
  852.     HRESULT hr;
  854.     if( m_pdds == NULL || strText == NULL )
  855.         return E_INVALIDARG;
  857.     // Make sure this surface is restored.
  858.     if( FAILED( hr = m_pdds->Restore() ) )
  859.         return hr;
  861.     if( FAILED( hr = m_pdds->GetDC( &hDC ) ) )
  862.         return hr;
  864.     // Set the background and foreground color
  865.     SetBkColor( hDC, crBackground );
  866.     SetTextColor( hDC, crForeground );
  868.     if( hFont )
  869.         SelectObject( hDC, hFont );
  871.     // Use GDI to draw the text on the surface
  872.     TextOut( hDC, dwOriginX, dwOriginY, strText, _tcslen(strText) );
  874.     if( FAILED( hr = m_pdds->ReleaseDC( hDC ) ) )
  875.         return hr;
  877.     return S_OK;
  878. }
  883. //-----------------------------------------------------------------------------
  884. // Name: CSurface::ReDrawBitmapOnSurface()
  885. // Desc: Load a bitmap from a file or resource into a DirectDraw surface.
  886. //       normaly used to re-load a surface after a restore.
  887. //-----------------------------------------------------------------------------
  888. HRESULT CSurface::DrawBitmap( TCHAR* strBMP, 
  889.                               DWORD dwDesiredWidth, DWORD dwDesiredHeight  )
  890. {
  891.     HBITMAP hBMP;
  892.     HRESULT hr;
  894.     if( m_pdds == NULL || strBMP == NULL )
  895.         return E_INVALIDARG;
  897.     //  Try to load the bitmap as a resource, if that fails, try it as a file
  898.     hBMP = (HBITMAP) LoadImage( GetModuleHandle(NULL), strBMP, 
  899.                                 IMAGE_BITMAP, dwDesiredWidth, dwDesiredHeight, 
  900.                                 LR_CREATEDIBSECTION );
  901.     if( hBMP == NULL )
  902.     {
  903.         hBMP = (HBITMAP) LoadImage( NULL, strBMP, IMAGE_BITMAP, 
  904.                                     dwDesiredWidth, dwDesiredHeight, 
  905.                                     LR_LOADFROMFILE | LR_CREATEDIBSECTION );
  906.         if( hBMP == NULL )
  907.             return E_FAIL;
  908.     }
  910.     // Draw the bitmap on this surface
  911.     if( FAILED( hr = DrawBitmap( hBMP, 0, 0, 0, 0 ) ) )
  912.     {
  913.         DeleteObject( hBMP );
  914.         return hr;
  915.     }
  917.     DeleteObject( hBMP );
  919.     return S_OK;
  920. }
  925. //-----------------------------------------------------------------------------
  926. // Name: 
  927. // Desc: 
  928. //-----------------------------------------------------------------------------
  929. HRESULT CSurface::SetColorKey( DWORD dwColorKey )
  930. {
  931.     if( NULL == m_pdds )
  932.         return E_POINTER;
  934.     m_bColorKeyed = TRUE;
  936.     DDCOLORKEY ddck;
  937.     ddck.dwColorSpaceLowValue  = ConvertGDIColor( dwColorKey );
  938.     ddck.dwColorSpaceHighValue = ConvertGDIColor( dwColorKey );
  939.     
  940.     return m_pdds->SetColorKey( DDCKEY_SRCBLT, &ddck );
  941. }
  947. //-----------------------------------------------------------------------------
  948. // Name: CSurface::ConvertGDIColor()
  949. // Desc: Converts a GDI color (0x00bbggrr) into the equivalent color on a 
  950. //       DirectDrawSurface using its pixel format.  
  951. //-----------------------------------------------------------------------------
  952. DWORD CSurface::ConvertGDIColor( COLORREF dwGDIColor )
  953. {
  954.     if( m_pdds == NULL )
  955.     return 0x00000000;
  957.     COLORREF       rgbT;
  958.     HDC            hdc;
  959.     DWORD          dw = CLR_INVALID;
  960.     DDSURFACEDESC2 ddsd;
  961.     HRESULT        hr;
  963.     //  Use GDI SetPixel to color match for us
  964.     if( dwGDIColor != CLR_INVALID && m_pdds->GetDC(&hdc) == DD_OK)
  965.     {
  966.         rgbT = GetPixel(hdc, 0, 0);     // Save current pixel value
  967.         SetPixel(hdc, 0, 0, dwGDIColor);       // Set our value
  968.         m_pdds->ReleaseDC(hdc);
  969.     }
  971.     // Now lock the surface so we can read back the converted color
  972.     ddsd.dwSize = sizeof(ddsd);
  973.     hr = m_pdds->Lock( NULL, &ddsd, DDLOCK_WAIT, NULL );
  974.     if( hr == DD_OK)
  975.     {
  976.         dw = *(DWORD *) ddsd.lpSurface; 
  977.         if( ddsd.ddpfPixelFormat.dwRGBBitCount < 32 ) // Mask it to bpp
  978.             dw &= ( 1 << ddsd.ddpfPixelFormat.dwRGBBitCount ) - 1;  
  979.         m_pdds->Unlock(NULL);
  980.     }
  982.     //  Now put the color that was there back.
  983.     if( dwGDIColor != CLR_INVALID && m_pdds->GetDC(&hdc) == DD_OK )
  984.     {
  985.         SetPixel( hdc, 0, 0, rgbT );
  986.         m_pdds->ReleaseDC(hdc);
  987.     }
  988.     
  989.     return dw;    
  990. }
  995. //-----------------------------------------------------------------------------
  996. // Name: CSurface::GetBitMaskInfo()
  997. // Desc: Returns the number of bits and the shift in the bit mask
  998. //-----------------------------------------------------------------------------
  999. HRESULT CSurface::GetBitMaskInfo( DWORD dwBitMask, DWORD* pdwShift, DWORD* pdwBits )
  1000. {
  1001.     DWORD dwShift = 0;
  1002.     DWORD dwBits  = 0; 
  1004.     if( pdwShift == NULL || pdwBits == NULL )
  1005.         return E_INVALIDARG;
  1007.     if( dwBitMask )
  1008.     {
  1009.         while( (dwBitMask & 1) == 0 )
  1010.         {
  1011.             dwShift++;
  1012.             dwBitMask >>= 1;
  1013.         }
  1014.     }
  1016.     while( (dwBitMask & 1) != 0 )
  1017.     {
  1018.         dwBits++;
  1019.         dwBitMask >>= 1;
  1020.     }
  1022.     *pdwShift = dwShift;
  1023.     *pdwBits  = dwBits;
  1025.     return S_OK;
  1026. }