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

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

游戏

开发平台：

Visual C++

d3dapp.cpp：源码内容
  1. //-----------------------------------------------------------------------------
  2. // File: D3DApp.cpp
  3. //
  4. // Desc: Application class for the Direct3D samples framework library.
  5. //
  6. // Copyright (c) Microsoft Corporation. All rights reserved.
  7. //-----------------------------------------------------------------------------
  8. #include "dxstdafx.h"
  13. //-----------------------------------------------------------------------------
  14. // Global access to the app (needed for the global WndProc())
  15. //-----------------------------------------------------------------------------
  16. static CD3DApplication* g_pD3DApp = NULL;
  21. //-----------------------------------------------------------------------------
  22. // Name: CD3DApplication()
  23. // Desc: Constructor
  24. //-----------------------------------------------------------------------------
  25. CD3DApplication::CD3DApplication()
  26. {
  27.     g_pD3DApp           = this;
  29.     m_pD3D              = NULL;
  30.     m_pd3dDevice        = NULL;
  31.     m_hWnd              = NULL;
  32.     m_hWndFocus         = NULL;
  33.     m_hMenu             = NULL;
  34.     m_bWindowed         = true;
  35.     m_bActive           = false;
  36.     m_bDeviceLost       = false;
  37.     m_bMinimized        = false;
  38.     m_bMaximized        = false;
  39.     m_bIgnoreSizeChange = false;
  40.     m_bDeviceObjectsInited = false;
  41.     m_bDeviceObjectsRestored = false;
  42.     m_dwCreateFlags     = 0;
  44.     m_bFrameMoving      = true;
  45.     m_bSingleStep       = false;
  46.     m_fTime             = 0.0f;
  47.     m_fElapsedTime      = 0.0f;
  48.     m_fFPS              = 0.0f;
  49.     m_strDeviceStats[0] = _T('');
  50.     m_strFrameStats[0]  = _T('');
  52.     m_strWindowTitle    = _T("D3D9 Application");
  53.     m_dwCreationWidth   = 400;
  54.     m_dwCreationHeight  = 300;
  55.     m_bShowCursorWhenFullscreen = false;
  56.     m_bStartFullscreen  = false;
  57.     m_bCreateMultithreadDevice = false;
  58.     m_bAllowDialogBoxMode = false;
  60.     Pause( true ); // Pause until we're ready to render
  62.     // When m_bClipCursorWhenFullscreen is true, the cursor is limited to
  63.     // the device window when the app goes fullscreen.  This prevents users
  64.     // from accidentally clicking outside the app window on a multimon system.
  65.     // This flag is turned off by default for debug builds, since it makes 
  66.     // multimon debugging difficult.
  67. #if defined(_DEBUG) || defined(DEBUG)
  68.     m_bClipCursorWhenFullscreen = false;
  69. #else
  70.     m_bClipCursorWhenFullscreen = true;
  71. #endif
  72. }
  77. //-----------------------------------------------------------------------------
  78. // Name: WndProc()
  79. // Desc: Static msg handler which passes messages to the application class.
  80. //-----------------------------------------------------------------------------
  81. LRESULT CALLBACK WndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
  82. {
  83.     return g_pD3DApp->MsgProc( hWnd, uMsg, wParam, lParam );
  84. }
  88. //-----------------------------------------------------------------------------
  89. // Name: ConfirmDeviceHelper()
  90. // Desc: Static function used by D3DEnumeration
  91. //-----------------------------------------------------------------------------
  92. bool CD3DApplication::ConfirmDeviceHelper( D3DCAPS9* pCaps, VertexProcessingType vertexProcessingType, 
  93.                          D3DFORMAT adapterFormat, D3DFORMAT backBufferFormat )
  94. {
  95.     DWORD dwBehavior;
  97.     if (vertexProcessingType == SOFTWARE_VP)
  98.         dwBehavior = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
  99.     else if (vertexProcessingType == MIXED_VP)
  100.         dwBehavior = D3DCREATE_MIXED_VERTEXPROCESSING;
  101.     else if (vertexProcessingType == HARDWARE_VP)
  102.         dwBehavior = D3DCREATE_HARDWARE_VERTEXPROCESSING;
  103.     else if (vertexProcessingType == PURE_HARDWARE_VP)
  104.         dwBehavior = D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_PUREDEVICE;
  105.     else
  106.         dwBehavior = 0; // TODO: throw exception
  107.     
  108.     return SUCCEEDED( g_pD3DApp->ConfirmDevice( pCaps, dwBehavior, adapterFormat, backBufferFormat ) );
  109. }
  114. //-----------------------------------------------------------------------------
  115. // Name: Create()
  116. // Desc: Here's what this function does:
  117. //       - Checks to make sure app is still active (if fullscreen, etc)
  118. //       - Checks to see if it is time to draw with DXUtil_Timer, if not, it just returns S_OK
  119. //       - Calls FrameMove() to recalculate new positions
  120. //       - Calls Render() to draw the new frame
  121. //       - Updates some frame count statistics
  122. //       - Calls m_pd3dDevice->Present() to display the rendered frame.
  123. //-----------------------------------------------------------------------------
  124. HRESULT CD3DApplication::Create( HINSTANCE hInstance )
  125. {
  126.     HRESULT hr;
  128.     // Create the Direct3D object
  129.     m_pD3D = Direct3DCreate9( D3D_SDK_VERSION );
  130.     if( m_pD3D == NULL )
  131.         return DisplayErrorMsg( D3DAPPERR_NODIRECT3D, MSGERR_APPMUSTEXIT );
  133.     // Build a list of Direct3D adapters, modes and devices. The
  134.     // ConfirmDevice() callback is used to confirm that only devices that
  135.     // meet the app's requirements are considered.
  136.     m_d3dEnumeration.SetD3D( m_pD3D );
  137.     m_d3dEnumeration.ConfirmDeviceCallback = ConfirmDeviceHelper;
  138.     if( FAILED( hr = m_d3dEnumeration.Enumerate() ) )
  139.     {
  140.         SAFE_RELEASE( m_pD3D );
  141.         return DisplayErrorMsg( hr, MSGERR_APPMUSTEXIT );
  142.     }
  144.     // Unless a substitute hWnd has been specified, create a window to
  145.     // render into
  146.     if( m_hWnd == NULL)
  147.     {
  148.         // Register the windows class
  149.         WNDCLASS wndClass = { 0, WndProc, 0, 0, hInstance,
  150.                               LoadIcon( hInstance, MAKEINTRESOURCE(IDI_MAIN_ICON) ),
  151.                               LoadCursor( NULL, IDC_ARROW ),
  152.                               (HBRUSH)GetStockObject(WHITE_BRUSH),
  153.                               NULL, _T("D3D Window") };
  154.         RegisterClass( &wndClass );
  156.         // Set the window's initial style
  157.         m_dwWindowStyle = WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | 
  158.                           WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_VISIBLE;
  159.         
  160.         HMENU hMenu = LoadMenu( hInstance, MAKEINTRESOURCE(IDR_MENU) );
  162.         // Set the window's initial width
  163.         RECT rc;
  164.         SetRect( &rc, 0, 0, m_dwCreationWidth, m_dwCreationHeight );        
  165.         AdjustWindowRect( &rc, m_dwWindowStyle, ( hMenu != NULL ) ? true : false );
  167.         // Create the render window
  168.         m_hWnd = CreateWindow( _T("D3D Window"), m_strWindowTitle, m_dwWindowStyle,
  169.                                CW_USEDEFAULT, CW_USEDEFAULT,
  170.                                (rc.right-rc.left), (rc.bottom-rc.top), 0,
  171.                                hMenu, hInstance, 0 );
  172.     }
  174.     // The focus window can be a specified to be a different window than the
  175.     // device window.  If not, use the device window as the focus window.
  176.     if( m_hWndFocus == NULL )
  177.         m_hWndFocus = m_hWnd;
  179.     // Save window properties
  180.     m_dwWindowStyle = GetWindowLong( m_hWnd, GWL_STYLE );
  181.     GetWindowRect( m_hWnd, &m_rcWindowBounds );
  182.     GetClientRect( m_hWnd, &m_rcWindowClient );
  184.     if( FAILED( hr = ChooseInitialD3DSettings() ) )
  185.     {
  186.         SAFE_RELEASE( m_pD3D );
  187.         return DisplayErrorMsg( hr, MSGERR_APPMUSTEXIT );
  188.     }
  190.     // Initialize the application timer
  191.     DXUtil_Timer( TIMER_START );
  193.     // Initialize the app's custom scene stuff
  194.     if( FAILED( hr = OneTimeSceneInit() ) )
  195.     {
  196.         SAFE_RELEASE( m_pD3D );
  197.         return DisplayErrorMsg( hr, MSGERR_APPMUSTEXIT );
  198.     }
  200.     // Initialize the 3D environment for the app
  201.     if( FAILED( hr = Initialize3DEnvironment() ) )
  202.     {
  203.         SAFE_RELEASE( m_pD3D );
  204.         return DisplayErrorMsg( hr, MSGERR_APPMUSTEXIT );
  205.     }
  207.     // The app is ready to go
  208.     Pause( false );
  210.     return S_OK;
  211. }
  216. //-----------------------------------------------------------------------------
  217. // Name: FindBestWindowedMode()
  218. // Desc: Sets up m_d3dSettings with best available windowed mode, subject to 
  219. //       the bRequireHAL and bRequireREF constraints.  Returns false if no such
  220. //       mode can be found.
  221. //-----------------------------------------------------------------------------
  222. bool CD3DApplication::FindBestWindowedMode( bool bRequireHAL, bool bRequireREF )
  223. {
  224.     // Get display mode of primary adapter (which is assumed to be where the window 
  225.     // will appear)
  226.     D3DDISPLAYMODE primaryDesktopDisplayMode;
  227.     m_pD3D->GetAdapterDisplayMode(0, &primaryDesktopDisplayMode);
  229.     D3DAdapterInfo* pBestAdapterInfo = NULL;
  230.     D3DDeviceInfo* pBestDeviceInfo = NULL;
  231.     D3DDeviceCombo* pBestDeviceCombo = NULL;
  233.     for( UINT iai = 0; iai < m_d3dEnumeration.m_pAdapterInfoList->Count(); iai++ )
  234.     {
  235.         D3DAdapterInfo* pAdapterInfo = (D3DAdapterInfo*)m_d3dEnumeration.m_pAdapterInfoList->GetPtr(iai);
  236.         for( UINT idi = 0; idi < pAdapterInfo->pDeviceInfoList->Count(); idi++ )
  237.         {
  238.             D3DDeviceInfo* pDeviceInfo = (D3DDeviceInfo*)pAdapterInfo->pDeviceInfoList->GetPtr(idi);
  239.             if (bRequireHAL && pDeviceInfo->DevType != D3DDEVTYPE_HAL)
  240.                 continue;
  241.             if (bRequireREF && pDeviceInfo->DevType != D3DDEVTYPE_REF)
  242.                 continue;
  243.             for( UINT idc = 0; idc < pDeviceInfo->pDeviceComboList->Count(); idc++ )
  244.             {
  245.                 D3DDeviceCombo* pDeviceCombo = (D3DDeviceCombo*)pDeviceInfo->pDeviceComboList->GetPtr(idc);
  246.                 bool bAdapterMatchesBB = (pDeviceCombo->BackBufferFormat == pDeviceCombo->AdapterFormat);
  247.                 if (!pDeviceCombo->IsWindowed)
  248.                     continue;
  249.                 if (pDeviceCombo->AdapterFormat != primaryDesktopDisplayMode.Format)
  250.                     continue;
  251.                 // If we haven't found a compatible DeviceCombo yet, or if this set
  252.                 // is better (because it's a HAL, and/or because formats match better),
  253.                 // save it
  254.                 if( pBestDeviceCombo == NULL || 
  255.                     pBestDeviceCombo->DevType != D3DDEVTYPE_HAL && pDeviceCombo->DevType == D3DDEVTYPE_HAL ||
  256.                     pDeviceCombo->DevType == D3DDEVTYPE_HAL && bAdapterMatchesBB )
  257.                 {
  258.                     pBestAdapterInfo = pAdapterInfo;
  259.                     pBestDeviceInfo = pDeviceInfo;
  260.                     pBestDeviceCombo = pDeviceCombo;
  261.                     if( pDeviceCombo->DevType == D3DDEVTYPE_HAL && bAdapterMatchesBB )
  262.                     {
  263.                         // This windowed device combo looks great -- take it
  264.                         goto EndWindowedDeviceComboSearch;
  265.                     }
  266.                     // Otherwise keep looking for a better windowed device combo
  267.                 }
  268.             }
  269.         }
  270.     }
  271. EndWindowedDeviceComboSearch:
  272.     if (pBestDeviceCombo == NULL )
  273.         return false;
  275.     m_d3dSettings.pWindowed_AdapterInfo = pBestAdapterInfo;
  276.     m_d3dSettings.pWindowed_DeviceInfo = pBestDeviceInfo;
  277.     m_d3dSettings.pWindowed_DeviceCombo = pBestDeviceCombo;
  278.     m_d3dSettings.IsWindowed = true;
  279.     m_d3dSettings.Windowed_DisplayMode = primaryDesktopDisplayMode;
  280.     m_d3dSettings.Windowed_Width = m_rcWindowClient.right - m_rcWindowClient.left;
  281.     m_d3dSettings.Windowed_Height = m_rcWindowClient.bottom - m_rcWindowClient.top;
  282.     if (m_d3dEnumeration.AppUsesDepthBuffer)
  283.         m_d3dSettings.Windowed_DepthStencilBufferFormat = *(D3DFORMAT*)pBestDeviceCombo->pDepthStencilFormatList->GetPtr(0);
  284.     m_d3dSettings.Windowed_MultisampleType = *(D3DMULTISAMPLE_TYPE*)pBestDeviceCombo->pMultiSampleTypeList->GetPtr(0);
  285.     m_d3dSettings.Windowed_MultisampleQuality = 0;
  286.     m_d3dSettings.Windowed_VertexProcessingType = *(VertexProcessingType*)pBestDeviceCombo->pVertexProcessingTypeList->GetPtr(0);
  287.     m_d3dSettings.Windowed_PresentInterval = *(UINT*)pBestDeviceCombo->pPresentIntervalList->GetPtr(0);
  288.     return true;
  289. }
  294. //-----------------------------------------------------------------------------
  295. // Name: FindBestFullscreenMode()
  296. // Desc: Sets up m_d3dSettings with best available fullscreen mode, subject to 
  297. //       the bRequireHAL and bRequireREF constraints.  Returns false if no such
  298. //       mode can be found.
  299. //-----------------------------------------------------------------------------
  300. bool CD3DApplication::FindBestFullscreenMode( bool bRequireHAL, bool bRequireREF )
  301. {
  302.     // For fullscreen, default to first HAL DeviceCombo that supports the current desktop 
  303.     // display mode, or any display mode if HAL is not compatible with the desktop mode, or 
  304.     // non-HAL if no HAL is available
  305.     D3DDISPLAYMODE adapterDesktopDisplayMode;
  306.     D3DDISPLAYMODE bestAdapterDesktopDisplayMode;
  307.     D3DDISPLAYMODE bestDisplayMode;
  308.     bestAdapterDesktopDisplayMode.Width = 0;
  309.     bestAdapterDesktopDisplayMode.Height = 0;
  310.     bestAdapterDesktopDisplayMode.Format = D3DFMT_UNKNOWN;
  311.     bestAdapterDesktopDisplayMode.RefreshRate = 0;
  313.     D3DAdapterInfo* pBestAdapterInfo = NULL;
  314.     D3DDeviceInfo* pBestDeviceInfo = NULL;
  315.     D3DDeviceCombo* pBestDeviceCombo = NULL;
  317.     for( UINT iai = 0; iai < m_d3dEnumeration.m_pAdapterInfoList->Count(); iai++ )
  318.     {
  319.         D3DAdapterInfo* pAdapterInfo = (D3DAdapterInfo*)m_d3dEnumeration.m_pAdapterInfoList->GetPtr(iai);
  320.         m_pD3D->GetAdapterDisplayMode( pAdapterInfo->AdapterOrdinal, &adapterDesktopDisplayMode );
  321.         for( UINT idi = 0; idi < pAdapterInfo->pDeviceInfoList->Count(); idi++ )
  322.         {
  323.             D3DDeviceInfo* pDeviceInfo = (D3DDeviceInfo*)pAdapterInfo->pDeviceInfoList->GetPtr(idi);
  324.             if (bRequireHAL && pDeviceInfo->DevType != D3DDEVTYPE_HAL)
  325.                 continue;
  326.             if (bRequireREF && pDeviceInfo->DevType != D3DDEVTYPE_REF)
  327.                 continue;
  328.             for( UINT idc = 0; idc < pDeviceInfo->pDeviceComboList->Count(); idc++ )
  329.             {
  330.                 D3DDeviceCombo* pDeviceCombo = (D3DDeviceCombo*)pDeviceInfo->pDeviceComboList->GetPtr(idc);
  331.                 bool bAdapterMatchesBB = (pDeviceCombo->BackBufferFormat == pDeviceCombo->AdapterFormat);
  332.                 bool bAdapterMatchesDesktop = (pDeviceCombo->AdapterFormat == adapterDesktopDisplayMode.Format);
  333.                 if (pDeviceCombo->IsWindowed)
  334.                     continue;
  335.                 // If we haven't found a compatible set yet, or if this set
  336.                 // is better (because it's a HAL, and/or because formats match better),
  337.                 // save it
  338.                 if (pBestDeviceCombo == NULL ||
  339.                     pBestDeviceCombo->DevType != D3DDEVTYPE_HAL && pDeviceInfo->DevType == D3DDEVTYPE_HAL ||
  340.                     pDeviceCombo->DevType == D3DDEVTYPE_HAL && pBestDeviceCombo->AdapterFormat != adapterDesktopDisplayMode.Format && bAdapterMatchesDesktop ||
  341.                     pDeviceCombo->DevType == D3DDEVTYPE_HAL && bAdapterMatchesDesktop && bAdapterMatchesBB )
  342.                 {
  343.                     bestAdapterDesktopDisplayMode = adapterDesktopDisplayMode;
  344.                     pBestAdapterInfo = pAdapterInfo;
  345.                     pBestDeviceInfo = pDeviceInfo;
  346.                     pBestDeviceCombo = pDeviceCombo;
  347.                     if (pDeviceInfo->DevType == D3DDEVTYPE_HAL && bAdapterMatchesDesktop && bAdapterMatchesBB)
  348.                     {
  349.                         // This fullscreen device combo looks great -- take it
  350.                         goto EndFullscreenDeviceComboSearch;
  351.                     }
  352.                     // Otherwise keep looking for a better fullscreen device combo
  353.                 }
  354.             }
  355.         }
  356.     }
  357. EndFullscreenDeviceComboSearch:
  358.     if (pBestDeviceCombo == NULL)
  359.         return false;
  361.     // Need to find a display mode on the best adapter that uses pBestDeviceCombo->AdapterFormat
  362.     // and is as close to bestAdapterDesktopDisplayMode's res as possible
  363.     bestDisplayMode.Width = 0;
  364.     bestDisplayMode.Height = 0;
  365.     bestDisplayMode.Format = D3DFMT_UNKNOWN;
  366.     bestDisplayMode.RefreshRate = 0;
  367.     for( UINT idm = 0; idm < pBestAdapterInfo->pDisplayModeList->Count(); idm++ )
  368.     {
  369.         D3DDISPLAYMODE* pdm = (D3DDISPLAYMODE*)pBestAdapterInfo->pDisplayModeList->GetPtr(idm);
  370.         if( pdm->Format != pBestDeviceCombo->AdapterFormat )
  371.             continue;
  372.         if( pdm->Width == bestAdapterDesktopDisplayMode.Width &&
  373.             pdm->Height == bestAdapterDesktopDisplayMode.Height && 
  374.             pdm->RefreshRate == bestAdapterDesktopDisplayMode.RefreshRate )
  375.         {
  376.             // found a perfect match, so stop
  377.             bestDisplayMode = *pdm;
  378.             break;
  379.         }
  380.         else if( pdm->Width == bestAdapterDesktopDisplayMode.Width &&
  381.                  pdm->Height == bestAdapterDesktopDisplayMode.Height && 
  382.                  pdm->RefreshRate > bestDisplayMode.RefreshRate )
  383.         {
  384.             // refresh rate doesn't match, but width/height match, so keep this
  385.             // and keep looking
  386.             bestDisplayMode = *pdm;
  387.         }
  388.         else if( pdm->Width == bestAdapterDesktopDisplayMode.Width )
  389.         {
  390.             // width matches, so keep this and keep looking
  391.             bestDisplayMode = *pdm;
  392.         }
  393.         else if( bestDisplayMode.Width == 0 )
  394.         {
  395.             // we don't have anything better yet, so keep this and keep looking
  396.             bestDisplayMode = *pdm;
  397.         }
  398.     }
  400.     m_d3dSettings.pFullscreen_AdapterInfo = pBestAdapterInfo;
  401.     m_d3dSettings.pFullscreen_DeviceInfo = pBestDeviceInfo;
  402.     m_d3dSettings.pFullscreen_DeviceCombo = pBestDeviceCombo;
  403.     m_d3dSettings.IsWindowed = false;
  404.     m_d3dSettings.Fullscreen_DisplayMode = bestDisplayMode;
  405.     if (m_d3dEnumeration.AppUsesDepthBuffer)
  406.         m_d3dSettings.Fullscreen_DepthStencilBufferFormat = *(D3DFORMAT*)pBestDeviceCombo->pDepthStencilFormatList->GetPtr(0);
  407.     m_d3dSettings.Fullscreen_MultisampleType = *(D3DMULTISAMPLE_TYPE*)pBestDeviceCombo->pMultiSampleTypeList->GetPtr(0);
  408.     m_d3dSettings.Fullscreen_MultisampleQuality = 0;
  409.     m_d3dSettings.Fullscreen_VertexProcessingType = *(VertexProcessingType*)pBestDeviceCombo->pVertexProcessingTypeList->GetPtr(0);
  410.     m_d3dSettings.Fullscreen_PresentInterval = D3DPRESENT_INTERVAL_DEFAULT;
  411.     return true;
  412. }
  417. //-----------------------------------------------------------------------------
  418. // Name: ChooseInitialD3DSettings()
  419. // Desc: 
  420. //-----------------------------------------------------------------------------
  421. HRESULT CD3DApplication::ChooseInitialD3DSettings()
  422. {
  423.     bool bFoundFullscreen = FindBestFullscreenMode( false, false );
  424.     bool bFoundWindowed = FindBestWindowedMode( false, false );
  425.     m_d3dSettings.SetDeviceClip( false );
  427.     if( m_bStartFullscreen && bFoundFullscreen )
  428.         m_d3dSettings.IsWindowed = false;
  429.     if( !bFoundWindowed && bFoundFullscreen )
  430.         m_d3dSettings.IsWindowed = false;
  432.     if( !bFoundFullscreen && !bFoundWindowed )
  433.         return D3DAPPERR_NOCOMPATIBLEDEVICES;
  435.     return S_OK;
  436. }
  441. //-----------------------------------------------------------------------------
  442. // Name: MsgProc()
  443. // Desc: Message handling function.  Here's what this function does:
  444. //       - WM_PAINT: calls Render() and Present() is called if !m_bReady
  445. //       - WM_EXITSIZEMOVE: window size recalc'd and calls HandlePossibleSizeChange()
  446. //       - WM_CLOSE: calls Cleanup3dEnvironment(), DestroyMenu(), DestroyWindow(), PostQuitMessage()
  447. //       - WM_COMMAND: IDM_CHANGEDEVICE calls UserSelectNewDevice() to select a new device
  448. //       - WM_COMMAND: IDM_TOGGLEFULLSCREEN calls ToggleFullScreen() to toggle 
  449. //                  between fullscreen and windowed
  450. //       - WM_COMMAND: IDM_EXIT: shuts down the app with a WM_CLOSE 
  451. //       - anything not handled goes to DefWindowProc()     
  452. //-----------------------------------------------------------------------------
  453. LRESULT CD3DApplication::MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam,
  454.                                   LPARAM lParam )
  455. {
  456.     switch( uMsg )
  457.     {
  458.         case WM_PAINT:
  459.             // Handle paint messages when the app is paused
  460.             if( m_pd3dDevice && !m_bActive && 
  461.                 m_bDeviceObjectsInited && m_bDeviceObjectsRestored )
  462.             {
  463.                 HRESULT hr;
  464.                 Render();
  465.                 hr = m_pd3dDevice->Present( NULL, NULL, NULL, NULL );
  466.                 if( D3DERR_DEVICELOST == hr )
  467.                     m_bDeviceLost = true;
  468.             }
  469.             break;
  471.         case WM_GETMINMAXINFO:
  472.             ((MINMAXINFO*)lParam)->ptMinTrackSize.x = 100;
  473.             ((MINMAXINFO*)lParam)->ptMinTrackSize.y = 100;
  474.             break;
  476.         case WM_ENTERSIZEMOVE:
  477.             // Halt frame movement while the app is sizing or moving
  478.             Pause( true );
  479.             break;
  481.         case WM_SIZE:
  482.             // Pick up possible changes to window style due to maximize, etc.
  483.             if( m_bWindowed && m_hWnd != NULL )
  484.                 m_dwWindowStyle = GetWindowLong( m_hWnd, GWL_STYLE );
  486.             if( SIZE_MINIMIZED == wParam )
  487.             {
  488.                 if( m_bClipCursorWhenFullscreen && !m_bWindowed )
  489.                     ClipCursor( NULL );
  490.                 Pause( true ); // Pause while we're minimized
  491.                 m_bMinimized = true;
  492.                 m_bMaximized = false;
  493.             }
  494.             else if( SIZE_MAXIMIZED == wParam )
  495.             {
  496.                 if( m_bMinimized )
  497.                     Pause( false ); // Unpause since we're no longer minimized
  498.                 m_bMinimized = false;
  499.                 m_bMaximized = true;
  500.                 HandlePossibleSizeChange();
  501.             }
  502.             else if( SIZE_RESTORED == wParam )
  503.             {
  504.                 if( m_bMaximized )
  505.                 {
  506.                     m_bMaximized = false;
  507.                     HandlePossibleSizeChange();
  508.                 }
  509.                 else if( m_bMinimized)
  510.                 {
  511.                     Pause( false ); // Unpause since we're no longer minimized
  512.                     m_bMinimized = false;
  513.                     HandlePossibleSizeChange();
  514.                 }
  515.                 else
  516.                 {
  517.                     // If we're neither maximized nor minimized, the window size 
  518.                     // is changing by the user dragging the window edges.  In this 
  519.                     // case, we don't reset the device yet -- we wait until the 
  520.                     // user stops dragging, and a WM_EXITSIZEMOVE message comes.
  521.                 }
  522.             }
  523.             break;
  525.         case WM_EXITSIZEMOVE:
  526.             Pause( false );
  527.             HandlePossibleSizeChange();
  528.             break;
  530.         case WM_SETCURSOR:
  531.             // Turn off Windows cursor in fullscreen mode
  532.             if( m_bActive && !m_bWindowed )
  533.             {
  534.                 SetCursor( NULL );
  535.                 if( m_bShowCursorWhenFullscreen )
  536.                     m_pd3dDevice->ShowCursor( true );
  537.                 return true; // prevent Windows from setting cursor to window class cursor
  538.             }
  539.             break;
  541.          case WM_MOUSEMOVE:
  542.             if( m_bActive && m_pd3dDevice != NULL )
  543.             {
  544.                 POINT ptCursor;
  545.                 GetCursorPos( &ptCursor );
  546.                 if( !m_bWindowed )
  547.                     ScreenToClient( m_hWnd, &ptCursor );
  548.                 m_pd3dDevice->SetCursorPosition( ptCursor.x, ptCursor.y, 0 );
  549.             }
  550.             break;
  552.        case WM_ENTERMENULOOP:
  553.             // Pause the app when menus are displayed
  554.             Pause(true);
  555.             break;
  557.         case WM_EXITMENULOOP:
  558.             Pause(false);
  559.             break;
  561.         case WM_NCHITTEST:
  562.             // Prevent the user from selecting the menu in fullscreen mode
  563.             if( !m_bWindowed )
  564.                 return HTCLIENT;
  565.             break;
  567.         case WM_POWERBROADCAST:
  568.             switch( wParam )
  569.             {
  570.                 #ifndef PBT_APMQUERYSUSPEND
  571.                     #define PBT_APMQUERYSUSPEND 0x0000
  572.                 #endif
  573.                 case PBT_APMQUERYSUSPEND:
  574.                     // At this point, the app should save any data for open
  575.                     // network connections, files, etc., and prepare to go into
  576.                     // a suspended mode.
  577.                     return true;
  579.                 #ifndef PBT_APMRESUMESUSPEND
  580.                     #define PBT_APMRESUMESUSPEND 0x0007
  581.                 #endif
  582.                 case PBT_APMRESUMESUSPEND:
  583.                     // At this point, the app should recover any data, network
  584.                     // connections, files, etc., and resume running from when
  585.                     // the app was suspended.
  586.                     return true;
  587.             }
  588.             break;
  590.         case WM_SYSCOMMAND:
  591.             // Prevent moving/sizing and power loss in fullscreen mode
  592.             switch( wParam )
  593.             {
  594.                 case SC_MOVE:
  595.                 case SC_SIZE:
  596.                 case SC_MAXIMIZE:
  597.                 case SC_KEYMENU:
  598.                 case SC_MONITORPOWER:
  599.                     if( false == m_bWindowed )
  600.                         return 1;
  601.                     break;
  602.             }
  603.             break;
  605.         case WM_COMMAND:
  606.             switch( LOWORD(wParam) )
  607.             {
  608.                 case IDM_TOGGLESTART:
  609.                     // Toggle frame movement
  610.                     m_bFrameMoving = !m_bFrameMoving;
  611.                     DXUtil_Timer( m_bFrameMoving ? TIMER_START : TIMER_STOP );
  612.                     break;
  614.                 case IDM_SINGLESTEP:
  615.                     // Single-step frame movement
  616.                     if( false == m_bFrameMoving )
  617.                         DXUtil_Timer( TIMER_ADVANCE );
  618.                     else
  619.                         DXUtil_Timer( TIMER_STOP );
  620.                     m_bFrameMoving = false;
  621.                     m_bSingleStep  = true;
  622.                     break;
  624.                 case IDM_CHANGEDEVICE:
  625.                     // Prompt the user to select a new device or mode
  626.                     Pause(true);
  627.                     UserSelectNewDevice();
  628.                     Pause(false);
  629.                     return 0;
  631.                 case IDM_TOGGLEFULLSCREEN:
  632.                     // Toggle the fullscreen/window mode
  633.                     Pause( true );
  634.                     if( FAILED( ToggleFullscreen() ) )
  635.                         DisplayErrorMsg( D3DAPPERR_RESETFAILED, MSGERR_APPMUSTEXIT );
  636.                     Pause( false );                        
  637.                     return 0;
  639.                 case IDM_HELP:
  640.                     LaunchReadme();
  641.                     return 0;
  643.                 case IDM_EXIT:
  644.                     // Recieved key/menu command to exit app
  645.                     SendMessage( hWnd, WM_CLOSE, 0, 0 );
  646.                     return 0;
  647.             }
  648.             break;
  650.         case WM_CLOSE:
  651.             Cleanup3DEnvironment();
  652.             SAFE_RELEASE( m_pD3D );
  653.             FinalCleanup();
  654.             HMENU hMenu;
  655.             hMenu = GetMenu(hWnd);
  656.             if( hMenu != NULL )
  657.                 DestroyMenu( hMenu );
  658.             DestroyWindow( hWnd );
  659.             PostQuitMessage(0);
  660.             m_hWnd = NULL;
  661.             return 0;
  662.     }
  664.     return DefWindowProc( hWnd, uMsg, wParam, lParam );
  665. }
  670. //-----------------------------------------------------------------------------
  671. // Name: HandlePossibleSizeChange()
  672. // Desc: Reset the device if the client area size has changed.
  673. //-----------------------------------------------------------------------------
  674. HRESULT CD3DApplication::HandlePossibleSizeChange()
  675. {
  676.     HRESULT hr = S_OK;
  677.     RECT rcClientOld;
  678.     rcClientOld = m_rcWindowClient;
  680.     if( m_bIgnoreSizeChange )
  681.         return S_OK;
  683.     // Update window properties
  684.     GetWindowRect( m_hWnd, &m_rcWindowBounds );
  685.     GetClientRect( m_hWnd, &m_rcWindowClient );
  687.     if( rcClientOld.right - rcClientOld.left !=
  688.         m_rcWindowClient.right - m_rcWindowClient.left ||
  689.         rcClientOld.bottom - rcClientOld.top !=
  690.         m_rcWindowClient.bottom - m_rcWindowClient.top)
  691.     {
  692.         // A new window size will require a new backbuffer
  693.         // size, so the 3D structures must be changed accordingly.
  694.         Pause( true );
  696.         m_d3dpp.BackBufferWidth  = m_rcWindowClient.right - m_rcWindowClient.left;
  697.         m_d3dpp.BackBufferHeight = m_rcWindowClient.bottom - m_rcWindowClient.top;
  699.         m_d3dSettings.Windowed_Width = m_d3dpp.BackBufferWidth;
  700.         m_d3dSettings.Windowed_Height = m_d3dpp.BackBufferHeight;
  701.     
  702.         if( m_pd3dDevice != NULL )
  703.         {
  704.             // Reset the 3D environment
  705.             if( FAILED( hr = Reset3DEnvironment() ) )
  706.             {
  707.                 if( hr == D3DERR_DEVICELOST )
  708.                 {
  709.                     m_bDeviceLost = true;
  710.                     hr = S_OK;
  711.                 }
  712.                 else
  713.                 {
  714.                     if( hr != D3DERR_OUTOFVIDEOMEMORY )
  715.                         hr = D3DAPPERR_RESETFAILED;
  717.                     DisplayErrorMsg( hr, MSGERR_APPMUSTEXIT );
  718.                 }
  719.             }
  720.         }
  721.         Pause( false );
  722.     }
  723.     return hr;
  724. }
  729. //-----------------------------------------------------------------------------
  730. // Name: Initialize3DEnvironment()
  731. // Desc: Usually this function is not overridden.  Here's what this function does:
  732. //       - Sets the windowed flag to be either windowed or fullscreen
  733. //       - Sets parameters for z-buffer depth and back buffer
  734. //       - Creates the D3D device
  735. //       - Sets the window position (if windowed, that is)
  736. //       - Makes some determinations as to the abilites of the driver (HAL, etc)
  737. //       - Sets up some cursor stuff
  738. //       - Calls InitDeviceObjects()
  739. //       - Calls RestoreDeviceObjects()
  740. //       - If all goes well, m_bActive is set to TRUE, and the function returns
  741. //       - Otherwise, initialization is reattempted using the reference device
  742. //-----------------------------------------------------------------------------
  743. HRESULT CD3DApplication::Initialize3DEnvironment()
  744. {
  745.     HRESULT hr;
  747.     D3DAdapterInfo* pAdapterInfo = m_d3dSettings.PAdapterInfo();
  748.     D3DDeviceInfo* pDeviceInfo = m_d3dSettings.PDeviceInfo();
  750.     m_bWindowed = m_d3dSettings.IsWindowed;
  752.     // Prepare window for possible windowed/fullscreen change
  753.     AdjustWindowForChange();
  755.     // Set up the presentation parameters
  756.     BuildPresentParamsFromSettings();
  758.     if( pDeviceInfo->Caps.PrimitiveMiscCaps & D3DPMISCCAPS_NULLREFERENCE )
  759.     {
  760.         // Warn user about null ref device that can't render anything
  761.         DisplayErrorMsg( D3DAPPERR_NULLREFDEVICE, 0 );
  762.     }
  764.     DWORD behaviorFlags;
  765.     if (m_d3dSettings.GetVertexProcessingType() == SOFTWARE_VP)
  766.         behaviorFlags = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
  767.     else if (m_d3dSettings.GetVertexProcessingType() == MIXED_VP)
  768.         behaviorFlags = D3DCREATE_MIXED_VERTEXPROCESSING;
  769.     else if (m_d3dSettings.GetVertexProcessingType() == HARDWARE_VP)
  770.         behaviorFlags = D3DCREATE_HARDWARE_VERTEXPROCESSING;
  771.     else if (m_d3dSettings.GetVertexProcessingType() == PURE_HARDWARE_VP)
  772.         behaviorFlags = D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_PUREDEVICE;
  773.     else
  774.         behaviorFlags = 0; // TODO: throw exception
  776.     // Add multithreaded flag if requested by app
  777.     if( m_bCreateMultithreadDevice )
  778.         behaviorFlags |= D3DCREATE_MULTITHREADED;
  780.     // Create the device
  781.     hr = m_pD3D->CreateDevice( m_d3dSettings.AdapterOrdinal(), pDeviceInfo->DevType,
  782.                                m_hWndFocus, behaviorFlags, &m_d3dpp,
  783.                                &m_pd3dDevice );
  785.     if( SUCCEEDED(hr) )
  786.     {
  787.         // When moving from fullscreen to windowed mode, it is important to
  788.         // adjust the window size after recreating the device rather than
  789.         // beforehand to ensure that you get the window size you want.  For
  790.         // example, when switching from 640x480 fullscreen to windowed with
  791.         // a 1000x600 window on a 1024x768 desktop, it is impossible to set
  792.         // the window size to 1000x600 until after the display mode has
  793.         // changed to 1024x768, because windows cannot be larger than the
  794.         // desktop.
  795.         if( m_bWindowed )
  796.         {
  797.             SetWindowPos( m_hWnd, HWND_NOTOPMOST,
  798.                           m_rcWindowBounds.left, m_rcWindowBounds.top,
  799.                           ( m_rcWindowBounds.right - m_rcWindowBounds.left ),
  800.                           ( m_rcWindowBounds.bottom - m_rcWindowBounds.top ),
  801.                           SWP_SHOWWINDOW );
  802.         }
  804.         // Store device Caps
  805.         m_pd3dDevice->GetDeviceCaps( &m_d3dCaps );
  806.         m_dwCreateFlags = behaviorFlags;
  808.         // Store device description
  809.         if( pDeviceInfo->DevType == D3DDEVTYPE_REF )
  810.             lstrcpy( m_strDeviceStats, TEXT("REF") );
  811.         else if( pDeviceInfo->DevType == D3DDEVTYPE_HAL )
  812.             lstrcpy( m_strDeviceStats, TEXT("HAL") );
  813.         else if( pDeviceInfo->DevType == D3DDEVTYPE_SW )
  814.             lstrcpy( m_strDeviceStats, TEXT("SW") );
  816.         if( behaviorFlags & D3DCREATE_HARDWARE_VERTEXPROCESSING &&
  817.             behaviorFlags & D3DCREATE_PUREDEVICE )
  818.         {
  819.             if( pDeviceInfo->DevType == D3DDEVTYPE_HAL )
  820.                 lstrcat( m_strDeviceStats, TEXT(" (pure hw vp)") );
  821.             else
  822.                 lstrcat( m_strDeviceStats, TEXT(" (simulated pure hw vp)") );
  823.         }
  824.         else if( behaviorFlags & D3DCREATE_HARDWARE_VERTEXPROCESSING )
  825.         {
  826.             if( pDeviceInfo->DevType == D3DDEVTYPE_HAL )
  827.                 lstrcat( m_strDeviceStats, TEXT(" (hw vp)") );
  828.             else
  829.                 lstrcat( m_strDeviceStats, TEXT(" (simulated hw vp)") );
  830.         }
  831.         else if( behaviorFlags & D3DCREATE_MIXED_VERTEXPROCESSING )
  832.         {
  833.             if( pDeviceInfo->DevType == D3DDEVTYPE_HAL )
  834.                 lstrcat( m_strDeviceStats, TEXT(" (mixed vp)") );
  835.             else
  836.                 lstrcat( m_strDeviceStats, TEXT(" (simulated mixed vp)") );
  837.         }
  838.         else if( behaviorFlags & D3DCREATE_SOFTWARE_VERTEXPROCESSING )
  839.         {
  840.             lstrcat( m_strDeviceStats, TEXT(" (sw vp)") );
  841.         }
  843.         if( pDeviceInfo->DevType == D3DDEVTYPE_HAL )
  844.         {
  845.             // Be sure not to overflow m_strDeviceStats when appending the adapter 
  846.             // description, since it can be long.  Note that the adapter description
  847.             // is initially CHAR and must be converted to TCHAR.
  848.             lstrcat( m_strDeviceStats, TEXT(": ") );
  849.             const int cchDesc = sizeof(pAdapterInfo->AdapterIdentifier.Description);
  850.             TCHAR szDescription[cchDesc];
  851.             DXUtil_ConvertAnsiStringToGenericCch( szDescription, 
  852.                 pAdapterInfo->AdapterIdentifier.Description, cchDesc );
  853.             int maxAppend = sizeof(m_strDeviceStats) / sizeof(TCHAR) -
  854.                 lstrlen( m_strDeviceStats ) - 1;
  855.             _tcsncat( m_strDeviceStats, szDescription, maxAppend );
  856.         }
  858.         // Store render target surface desc
  859.         LPDIRECT3DSURFACE9 pBackBuffer = NULL;
  860.         m_pd3dDevice->GetBackBuffer( 0, 0, D3DBACKBUFFER_TYPE_MONO, &pBackBuffer );
  861.         pBackBuffer->GetDesc( &m_d3dsdBackBuffer );
  862.         pBackBuffer->Release();
  864.         // Set up the fullscreen cursor
  865.         if( m_bShowCursorWhenFullscreen && !m_bWindowed )
  866.         {
  867.             HCURSOR hCursor;
  868. #ifdef _WIN64
  869.             hCursor = (HCURSOR)GetClassLongPtr( m_hWnd, GCLP_HCURSOR );
  870. #else
  871.             hCursor = (HCURSOR)ULongToHandle( GetClassLong( m_hWnd, GCL_HCURSOR ) );
  872. #endif
  873.             D3DUtil_SetDeviceCursor( m_pd3dDevice, hCursor, true );
  874.             m_pd3dDevice->ShowCursor( true );
  875.         }
  877.         // Confine cursor to fullscreen window
  878.         if( m_bClipCursorWhenFullscreen )
  879.         {
  880.             if (!m_bWindowed )
  881.             {
  882.                 RECT rcWindow;
  883.                 GetWindowRect( m_hWnd, &rcWindow );
  884.                 ClipCursor( &rcWindow );
  885.             }
  886.             else
  887.             {
  888.                 ClipCursor( NULL );
  889.             }
  890.         }
  892.         // Initialize the app's device-dependent objects
  893.         hr = InitDeviceObjects();
  894.         if( FAILED(hr) )
  895.         {
  896.             DeleteDeviceObjects();
  897.         }
  898.         else
  899.         {
  900.             m_bDeviceObjectsInited = true;
  901.             hr = RestoreDeviceObjects();
  902.             if( FAILED(hr) )
  903.             {
  904.                 InvalidateDeviceObjects();
  905.             }
  906.             else
  907.             {
  908.                 m_bDeviceObjectsRestored = true;
  909.                 return S_OK;
  910.             }
  911.         }
  913.         // Cleanup before we try again
  914.         Cleanup3DEnvironment();
  915.     }
  917.     // If that failed, fall back to the reference rasterizer
  918.     if( hr != D3DAPPERR_MEDIANOTFOUND && 
  919.         hr != HRESULT_FROM_WIN32( ERROR_FILE_NOT_FOUND ) && 
  920.         pDeviceInfo->DevType == D3DDEVTYPE_HAL )
  921.     {
  922.         if (FindBestWindowedMode(false, true))
  923.         {
  924.             m_bWindowed = true;
  925.             AdjustWindowForChange();
  926.             // Make sure main window isn't topmost, so error message is visible
  927.             SetWindowPos( m_hWnd, HWND_NOTOPMOST,
  928.                           m_rcWindowBounds.left, m_rcWindowBounds.top,
  929.                           ( m_rcWindowBounds.right - m_rcWindowBounds.left ),
  930.                           ( m_rcWindowBounds.bottom - m_rcWindowBounds.top ),
  931.                           SWP_SHOWWINDOW );
  933.             // Let the user know we are switching from HAL to the reference rasterizer
  934.             DisplayErrorMsg( hr, MSGWARN_SWITCHEDTOREF );
  936.             hr = Initialize3DEnvironment();
  937.         }
  938.     }
  939.     return hr;
  940. }
  945. //-----------------------------------------------------------------------------
  946. // Name: BuildPresentParamsFromSettings()
  947. // Desc:
  948. //-----------------------------------------------------------------------------
  949. void CD3DApplication::BuildPresentParamsFromSettings()
  950. {
  951.     m_d3dpp.Windowed               = m_d3dSettings.IsWindowed;
  952.     m_d3dpp.BackBufferCount        = 1;
  953.     m_d3dpp.MultiSampleType        = m_d3dSettings.MultisampleType();
  954.     m_d3dpp.MultiSampleQuality     = m_d3dSettings.MultisampleQuality();
  955.     m_d3dpp.SwapEffect             = D3DSWAPEFFECT_DISCARD;
  956.     m_d3dpp.EnableAutoDepthStencil = m_d3dEnumeration.AppUsesDepthBuffer;
  957.     m_d3dpp.hDeviceWindow          = m_hWnd;
  958.     if( m_d3dEnumeration.AppUsesDepthBuffer )
  959.     {
  960.         m_d3dpp.Flags              = D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL;
  961.         m_d3dpp.AutoDepthStencilFormat = m_d3dSettings.DepthStencilBufferFormat();
  962.     }
  963.     else
  964.     {
  965.         m_d3dpp.Flags              = 0;
  966.     }
  968.     if ( m_d3dSettings.DeviceClip() )
  969.         m_d3dpp.Flags |= D3DPRESENTFLAG_DEVICECLIP;
  971.     if( m_bWindowed )
  972.     {
  973.         m_d3dpp.BackBufferWidth  = m_d3dSettings.Windowed_Width;
  974.         m_d3dpp.BackBufferHeight = m_d3dSettings.Windowed_Height;
  975.         m_d3dpp.BackBufferFormat = m_d3dSettings.PDeviceCombo()->BackBufferFormat;
  976.         m_d3dpp.FullScreen_RefreshRateInHz = 0;
  977.         m_d3dpp.PresentationInterval = m_d3dSettings.PresentInterval();
  978.     }
  979.     else
  980.     {
  981.         m_d3dpp.BackBufferWidth  = m_d3dSettings.DisplayMode().Width;
  982.         m_d3dpp.BackBufferHeight = m_d3dSettings.DisplayMode().Height;
  983.         m_d3dpp.BackBufferFormat = m_d3dSettings.PDeviceCombo()->BackBufferFormat;
  984.         m_d3dpp.FullScreen_RefreshRateInHz = m_d3dSettings.Fullscreen_DisplayMode.RefreshRate;
  985.         m_d3dpp.PresentationInterval = m_d3dSettings.PresentInterval();
  987.         if( m_bAllowDialogBoxMode )
  988.         {
  989.             // Make the back buffers lockable in fullscreen mode
  990.             // so we can show dialog boxes via SetDialogBoxMode() 
  991.             // but since lockable back buffers incur a performance cost on 
  992.             // some graphics hardware configurations we'll only 
  993.             // enable lockable backbuffers where SetDialogBoxMode() would work.
  994.             if ( (m_d3dpp.BackBufferFormat == D3DFMT_X1R5G5B5 || m_d3dpp.BackBufferFormat == D3DFMT_R5G6B5 || m_d3dpp.BackBufferFormat == D3DFMT_X8R8G8B8 ) &&
  995.                 ( m_d3dpp.MultiSampleType == D3DMULTISAMPLE_NONE ) &&
  996.                 ( m_d3dpp.SwapEffect == D3DSWAPEFFECT_DISCARD ) )
  997.             {
  998.                 m_d3dpp.Flags |= D3DPRESENTFLAG_LOCKABLE_BACKBUFFER;
  999.             }
  1000.         }
  1001.     }
  1002. }
  1007. //-----------------------------------------------------------------------------
  1008. // Name: Reset3DEnvironment()
  1009. // Desc: Usually this function is not overridden.  Here's what this function does:
  1010. //       - Sets the windowed flag to be either windowed or fullscreen
  1011. //       - Sets parameters for z-buffer depth and back buffer
  1012. //       - Creates the D3D device
  1013. //       - Sets the window position (if windowed, that is)
  1014. //       - Makes some determinations as to the abilites of the driver (HAL, etc)
  1015. //       - Sets up some cursor stuff
  1016. //       - Calls InitDeviceObjects()
  1017. //       - Calls RestoreDeviceObjects()
  1018. //       - If all goes well, m_bActive is set to TRUE, and the function returns
  1019. //       - Otherwise, initialization is reattempted using the reference device
  1020. //-----------------------------------------------------------------------------
  1021. HRESULT CD3DApplication::Reset3DEnvironment()
  1022. {
  1023.     HRESULT hr;
  1025.     // Release all vidmem objects
  1026.     if( m_bDeviceObjectsRestored )
  1027.     {
  1028.         m_bDeviceObjectsRestored = false;
  1029.         InvalidateDeviceObjects();
  1030.     }
  1031.     // Reset the device
  1032.     if( FAILED( hr = m_pd3dDevice->Reset( &m_d3dpp ) ) )
  1033.         return hr;
  1035.     // Store render target surface desc
  1036.     LPDIRECT3DSURFACE9 pBackBuffer;
  1037.     m_pd3dDevice->GetBackBuffer( 0, 0, D3DBACKBUFFER_TYPE_MONO, &pBackBuffer );
  1038.     pBackBuffer->GetDesc( &m_d3dsdBackBuffer );
  1039.     pBackBuffer->Release();
  1041.     // Set up the fullscreen cursor
  1042.     if( m_bShowCursorWhenFullscreen && !m_bWindowed )
  1043.     {
  1044.         HCURSOR hCursor;
  1045. #ifdef _WIN64
  1046.         hCursor = (HCURSOR)GetClassLongPtr( m_hWnd, GCLP_HCURSOR );
  1047. #else
  1048.         hCursor = (HCURSOR)ULongToHandle( GetClassLong( m_hWnd, GCL_HCURSOR ) );
  1049. #endif
  1050.         D3DUtil_SetDeviceCursor( m_pd3dDevice, hCursor, true );
  1051.         m_pd3dDevice->ShowCursor( true );
  1052.     }
  1054.     // Confine cursor to fullscreen window
  1055.     if( m_bClipCursorWhenFullscreen )
  1056.     {
  1057.         if (!m_bWindowed )
  1058.         {
  1059.             RECT rcWindow;
  1060.             GetWindowRect( m_hWnd, &rcWindow );
  1061.             ClipCursor( &rcWindow );
  1062.         }
  1063.         else
  1064.         {
  1065.             ClipCursor( NULL );
  1066.         }
  1067.     }
  1069.     // Initialize the app's device-dependent objects
  1070.     hr = RestoreDeviceObjects();
  1071.     if( FAILED(hr) )
  1072.     {
  1073.         InvalidateDeviceObjects();
  1074.         return hr;
  1075.     }
  1076.     m_bDeviceObjectsRestored = true;
  1078.     // If the app is paused, trigger the rendering of the current frame
  1079.     if( false == m_bFrameMoving )
  1080.     {
  1081.         m_bSingleStep = true;
  1082.         DXUtil_Timer( TIMER_START );
  1083.         DXUtil_Timer( TIMER_STOP );
  1084.     }
  1086.     return S_OK;
  1087. }
  1092. //-----------------------------------------------------------------------------
  1093. // Name: ToggleFullScreen()
  1094. // Desc: Called when user toggles between fullscreen mode and windowed mode
  1095. //-----------------------------------------------------------------------------
  1096. HRESULT CD3DApplication::ToggleFullscreen()
  1097. {
  1098.     HRESULT hr;
  1099.     int AdapterOrdinalOld = m_d3dSettings.AdapterOrdinal();
  1100.     D3DDEVTYPE DevTypeOld = m_d3dSettings.DevType();
  1102.     Pause( true );
  1103.     m_bIgnoreSizeChange = true;
  1105.     // Toggle the windowed state
  1106.     m_bWindowed = !m_bWindowed;
  1107.     m_d3dSettings.IsWindowed = m_bWindowed;
  1109.     // Prepare window for windowed/fullscreen change
  1110.     AdjustWindowForChange();
  1112.     // If AdapterOrdinal and DevType are the same, we can just do a Reset().
  1113.     // If they've changed, we need to do a complete device teardown/rebuild.
  1114.     if (m_d3dSettings.AdapterOrdinal() == AdapterOrdinalOld &&
  1115.         m_d3dSettings.DevType() == DevTypeOld)
  1116.     {
  1117.         // Reset the 3D device
  1118.         BuildPresentParamsFromSettings();
  1119.         hr = Reset3DEnvironment();
  1120.     }
  1121.     else
  1122.     {
  1123.         Cleanup3DEnvironment();
  1124.         hr = Initialize3DEnvironment();
  1125.     }
  1126.     if( FAILED( hr ) )
  1127.     {
  1128.         if( hr != D3DERR_OUTOFVIDEOMEMORY )
  1129.             hr = D3DAPPERR_RESETFAILED;
  1130.         m_bIgnoreSizeChange = false;
  1131.         if( !m_bWindowed )
  1132.         {
  1133.             // Restore window type to windowed mode
  1134.             m_bWindowed = !m_bWindowed;
  1135.             m_d3dSettings.IsWindowed = m_bWindowed;
  1136.             AdjustWindowForChange();
  1137.             SetWindowPos( m_hWnd, HWND_NOTOPMOST,
  1138.                         m_rcWindowBounds.left, m_rcWindowBounds.top,
  1139.                         ( m_rcWindowBounds.right - m_rcWindowBounds.left ),
  1140.                         ( m_rcWindowBounds.bottom - m_rcWindowBounds.top ),
  1141.                         SWP_SHOWWINDOW );
  1142.         }
  1143.         return DisplayErrorMsg( hr, MSGERR_APPMUSTEXIT );
  1144.     }
  1146.     m_bIgnoreSizeChange = false;
  1148.     // When moving from fullscreen to windowed mode, it is important to
  1149.     // adjust the window size after resetting the device rather than
  1150.     // beforehand to ensure that you get the window size you want.  For
  1151.     // example, when switching from 640x480 fullscreen to windowed with
  1152.     // a 1000x600 window on a 1024x768 desktop, it is impossible to set
  1153.     // the window size to 1000x600 until after the display mode has
  1154.     // changed to 1024x768, because windows cannot be larger than the
  1155.     // desktop.
  1156.     if( m_bWindowed )
  1157.     {
  1158.         SetWindowPos( m_hWnd, HWND_NOTOPMOST,
  1159.                       m_rcWindowBounds.left, m_rcWindowBounds.top,
  1160.                       ( m_rcWindowBounds.right - m_rcWindowBounds.left ),
  1161.                       ( m_rcWindowBounds.bottom - m_rcWindowBounds.top ),
  1162.                       SWP_SHOWWINDOW );
  1163.     }
  1165.     GetClientRect( m_hWnd, &m_rcWindowClient );  // Update our copy
  1167.     Pause( false );
  1168.     return S_OK;
  1169. }
  1174. //-----------------------------------------------------------------------------
  1175. // Name: ForceWindowed()
  1176. // Desc: Switch to a windowed mode, even if that means picking a new device
  1177. //       and/or adapter
  1178. //-----------------------------------------------------------------------------
  1179. HRESULT CD3DApplication::ForceWindowed()
  1180. {
  1181.     HRESULT hr;
  1183.     if( m_bWindowed )
  1184.         return S_OK;
  1186.     if( !FindBestWindowedMode(false, false) )
  1187.     {
  1188.         return E_FAIL;
  1189.     }
  1190.     m_bWindowed = true;
  1192.     // Now destroy the current 3D device objects, then reinitialize
  1194.     Pause( true );
  1196.     // Release all scene objects that will be re-created for the new device
  1197.     Cleanup3DEnvironment();
  1199.     // Create the new device
  1200.     if( FAILED(hr = Initialize3DEnvironment() ) )
  1201.         return DisplayErrorMsg( hr, MSGERR_APPMUSTEXIT );
  1203.     Pause( false );
  1204.     return S_OK;
  1205. }
  1210. //-----------------------------------------------------------------------------
  1211. // Name: AdjustWindowForChange()
  1212. // Desc: Prepare the window for a possible change between windowed mode and
  1213. //       fullscreen mode.  This function is virtual and thus can be overridden
  1214. //       to provide different behavior, such as switching to an entirely
  1215. //       different window for fullscreen mode (as in the MFC sample apps).
  1216. //-----------------------------------------------------------------------------
  1217. HRESULT CD3DApplication::AdjustWindowForChange()
  1218. {
  1219.     if( m_bWindowed )
  1220.     {
  1221.         // Set windowed-mode style
  1222.         SetWindowLong( m_hWnd, GWL_STYLE, m_dwWindowStyle );
  1223.         if( m_hMenu != NULL )
  1224.         {
  1225.             SetMenu( m_hWnd, m_hMenu );
  1226.             m_hMenu = NULL;
  1227.         }
  1228.     }
  1229.     else
  1230.     {
  1231.         // Set fullscreen-mode style
  1232.         SetWindowLong( m_hWnd, GWL_STYLE, WS_POPUP|WS_SYSMENU|WS_VISIBLE );
  1233.         if( m_hMenu == NULL )
  1234.         {
  1235.             m_hMenu = GetMenu( m_hWnd );
  1236.             SetMenu( m_hWnd, NULL );
  1237.         }
  1238.     }
  1239.     return S_OK;
  1240. }
  1245. //-----------------------------------------------------------------------------
  1246. // Name: UserSelectNewDevice()
  1247. // Desc: Displays a dialog so the user can select a new adapter, device, or
  1248. //       display mode, and then recreates the 3D environment if needed
  1249. //-----------------------------------------------------------------------------
  1250. HRESULT CD3DApplication::UserSelectNewDevice()
  1251. {
  1252.     HRESULT hr;
  1253.     bool bDialogBoxMode = false;
  1254.     bool bOldWindowed = m_bWindowed;  // Preserve original windowed flag
  1256.     if( m_bWindowed == false )
  1257.     {
  1258.         // See if the current settings comply with the rules
  1259.         // for allowing SetDialogBoxMode().  
  1260.         if( (m_d3dpp.BackBufferFormat == D3DFMT_X1R5G5B5 || m_d3dpp.BackBufferFormat == D3DFMT_R5G6B5 || m_d3dpp.BackBufferFormat == D3DFMT_X8R8G8B8 ) &&
  1261.             ( m_d3dpp.MultiSampleType == D3DMULTISAMPLE_NONE ) &&
  1262.             ( m_d3dpp.SwapEffect == D3DSWAPEFFECT_DISCARD ) &&
  1263.             ( (m_d3dpp.Flags & D3DPRESENTFLAG_LOCKABLE_BACKBUFFER) == D3DPRESENTFLAG_LOCKABLE_BACKBUFFER ) &&
  1264.             ( (m_dwCreateFlags & D3DCREATE_ADAPTERGROUP_DEVICE) != D3DCREATE_ADAPTERGROUP_DEVICE ) )
  1265.         {
  1266.             if( SUCCEEDED( m_pd3dDevice->SetDialogBoxMode( true ) ) )
  1267.                 bDialogBoxMode = true;
  1268.         }
  1270.         // If SetDialogBoxMode(true) didn't work then we can't display dialogs  
  1271.         // in fullscreen mode so we'll go back to windowed mode
  1272.         if( FALSE == bDialogBoxMode )
  1273.         {
  1274.             if( FAILED( ToggleFullscreen() ) )
  1275.             {
  1276.                 DisplayErrorMsg( D3DAPPERR_RESETFAILED, MSGERR_APPMUSTEXIT );
  1277.                 return E_FAIL;
  1278.             }
  1279.         }
  1280.     }
  1282.     // The dialog should use the mode the sample runs in, not
  1283.     // the mode that the dialog runs in.
  1284.     CD3DSettings tempSettings = m_d3dSettings;
  1285.     tempSettings.IsWindowed = bOldWindowed;
  1286.     CD3DSettingsDialog settingsDialog( &m_d3dEnumeration, &tempSettings);
  1287.     INT_PTR nResult = settingsDialog.ShowDialog( m_hWnd );
  1289.     // Before creating the device, switch back to SetDialogBoxMode(false) 
  1290.     // mode to allow the user to pick multisampling or backbuffer formats 
  1291.     // not supported by SetDialogBoxMode(true) but typical apps wouldn't 
  1292.     // need to switch back.
  1293.     if( bDialogBoxMode )
  1294.         m_pd3dDevice->SetDialogBoxMode( false );
  1296.     if( nResult != IDOK )
  1297.     {
  1298.         // If we had to switch mode to display the dialog, we
  1299.         // need to go back to the original mode the sample
  1300.         // was running in.
  1301.         if( bOldWindowed != m_bWindowed && FAILED( ToggleFullscreen() ) )
  1302.         {
  1303.             DisplayErrorMsg( D3DAPPERR_RESETFAILED, MSGERR_APPMUSTEXIT );
  1304.             return E_FAIL;
  1305.         }
  1307.         return S_OK;
  1308.     }
  1310.     settingsDialog.GetFinalSettings( &m_d3dSettings );
  1312.     m_bWindowed = m_d3dSettings.IsWindowed;
  1314.     // Release all scene objects that will be re-created for the new device
  1315.     Cleanup3DEnvironment();
  1317.     // Inform the display class of the change. It will internally
  1318.     // re-create valid surfaces, a d3ddevice, etc.
  1319.     if( FAILED( hr = Initialize3DEnvironment() ) )
  1320.     {
  1321.         if( hr != D3DERR_OUTOFVIDEOMEMORY )
  1322.             hr = D3DAPPERR_RESETFAILED;
  1323.         if( !m_bWindowed )
  1324.         {
  1325.             // Restore window type to windowed mode
  1326.             m_bWindowed = !m_bWindowed;
  1327.             m_d3dSettings.IsWindowed = m_bWindowed;
  1328.             AdjustWindowForChange();
  1329.             SetWindowPos( m_hWnd, HWND_NOTOPMOST,
  1330.                         m_rcWindowBounds.left, m_rcWindowBounds.top,
  1331.                         ( m_rcWindowBounds.right - m_rcWindowBounds.left ),
  1332.                         ( m_rcWindowBounds.bottom - m_rcWindowBounds.top ),
  1333.                         SWP_SHOWWINDOW );
  1334.         }
  1335.         return DisplayErrorMsg( hr, MSGERR_APPMUSTEXIT );
  1336.     }
  1338.     // If the app is paused, trigger the rendering of the current frame
  1339.     if( false == m_bFrameMoving )
  1340.     {
  1341.         m_bSingleStep = true;
  1342.         DXUtil_Timer( TIMER_START );
  1343.         DXUtil_Timer( TIMER_STOP );
  1344.     }
  1345.     return S_OK;
  1346. }
  1351. //-----------------------------------------------------------------------------
  1352. // Name: Run()
  1353. // Desc: Here's what this function does:
  1354. //       - Runs through the message loop.  If no messages are waiting, then
  1355. //         it calls Render3DEnvironment().
  1356. //       - Messages are forwarded (through WndProc) to CD3DApplication::MsgProc()
  1357. //-----------------------------------------------------------------------------
  1358. INT CD3DApplication::Run()
  1359. {
  1360.     // Load keyboard accelerators
  1361.     HACCEL hAccel = LoadAccelerators( NULL, MAKEINTRESOURCE(IDR_MAIN_ACCEL) );
  1363.     // Now we're ready to recieve and process Windows messages.
  1364.     HRESULT hr;
  1365.     bool bGotMsg;
  1366.     MSG  msg;
  1367.     msg.message = WM_NULL;
  1368.     PeekMessage( &msg, NULL, 0U, 0U, PM_NOREMOVE );
  1370.     while( WM_QUIT != msg.message  )
  1371.     {
  1372.         // Use PeekMessage() if the app is active, so we can use idle time to
  1373.         // render the scene. Else, use GetMessage() to avoid eating CPU time.
  1374.         if( m_bActive )
  1375.             bGotMsg = ( PeekMessage( &msg, NULL, 0U, 0U, PM_REMOVE ) != 0 );
  1376.         else
  1377.             bGotMsg = ( GetMessage( &msg, NULL, 0U, 0U ) != 0 );
  1379.         if( bGotMsg )
  1380.         {
  1381.             // Translate and dispatch the message
  1382.             if( hAccel == NULL || m_hWnd == NULL || 
  1383.                 0 == TranslateAccelerator( m_hWnd, hAccel, &msg ) )
  1384.             {
  1385.                 TranslateMessage( &msg );
  1386.                 DispatchMessage( &msg );
  1387.             }
  1388.         }
  1389.         else
  1390.         {
  1391.             if( m_bDeviceLost )
  1392.             {
  1393.                 // Yield some CPU time to other processes
  1394.                 Sleep( 100 ); // 100 milliseconds
  1395.             }
  1396.             // Render a frame during idle time (no messages are waiting)
  1397.             if( m_bActive )
  1398.             {
  1399.                 if( FAILED( hr = Render3DEnvironment() ) )
  1400.                     DisplayErrorMsg( hr, MSGERR_APPMUSTEXIT );
  1401.             }
  1402.         }
  1403.     }
  1404.     if( hAccel != NULL )
  1405.         DestroyAcceleratorTable( hAccel );
  1407.     return (INT)msg.wParam;
  1408. }
  1413. //-----------------------------------------------------------------------------
  1414. // Name: Render3DEnvironment()
  1415. // Desc: Here's what this function does:
  1416. //       - Checks to make sure app is still active (if fullscreen, etc)
  1417. //       - Checks to see if it is time to draw with DXUtil_Timer, if not, it just returns S_OK
  1418. //       - Calls FrameMove() to recalculate new positions
  1419. //       - Calls Render() to draw the new frame
  1420. //       - Updates some frame count statistics
  1421. //       - Calls m_pd3dDevice->Present() to display the rendered frame.
  1422. //-----------------------------------------------------------------------------
  1423. HRESULT CD3DApplication::Render3DEnvironment()
  1424. {
  1425.     HRESULT hr;
  1427.     if( m_bDeviceLost )
  1428.     {
  1429.         // Test the cooperative level to see if it's okay to render
  1430.         if( FAILED( hr = m_pd3dDevice->TestCooperativeLevel() ) )
  1431.         {
  1432.             // If the device was lost, do not render until we get it back
  1433.             if( D3DERR_DEVICELOST == hr )
  1434.                 return S_OK;
  1436.             // Check if the device needs to be reset.
  1437.             if( D3DERR_DEVICENOTRESET == hr )
  1438.             {
  1439.                 // If we are windowed, read the desktop mode and use the same format for
  1440.                 // the back buffer
  1441.                 if( m_bWindowed )
  1442.                 {
  1443.                     D3DAdapterInfo* pAdapterInfo = m_d3dSettings.PAdapterInfo();
  1444.                     m_pD3D->GetAdapterDisplayMode( pAdapterInfo->AdapterOrdinal, &m_d3dSettings.Windowed_DisplayMode );
  1445.                     m_d3dpp.BackBufferFormat = m_d3dSettings.Windowed_DisplayMode.Format;
  1446.                 }
  1448.                 if( FAILED( hr = Reset3DEnvironment() ) )
  1449.                     return DisplayErrorMsg( D3DAPPERR_RESETFAILED, MSGERR_APPMUSTEXIT );
  1450.             }
  1451.             return hr;
  1452.         }
  1453.         m_bDeviceLost = false;
  1454.     }
  1456.     // Get the app's time, in seconds. Skip rendering if no time elapsed
  1457.     FLOAT fAppTime        = DXUtil_Timer( TIMER_GETAPPTIME );
  1458.     FLOAT fElapsedAppTime = DXUtil_Timer( TIMER_GETELAPSEDTIME );
  1459.     if( ( 0.0f == fElapsedAppTime ) && m_bFrameMoving )
  1460.         return S_OK;
  1462.     // FrameMove (animate) the scene
  1463.     if( m_bFrameMoving || m_bSingleStep )
  1464.     {
  1465.         // Store the time for the app
  1466.         m_fTime        = fAppTime;
  1467.         m_fElapsedTime = fElapsedAppTime;
  1469.         // Frame move the scene
  1470.         if( FAILED( hr = FrameMove() ) )
  1471.             return hr;
  1473.         m_bSingleStep = false;
  1474.     } else
  1475.         m_fElapsedTime = fElapsedAppTime;
  1477.     // Render the scene as normal
  1478.     if( FAILED( hr = Render() ) )
  1479.         return hr;
  1481.     UpdateStats();
  1483.     // Show the frame on the primary surface.
  1484.     hr = m_pd3dDevice->Present( NULL, NULL, NULL, NULL );
  1485.     if( D3DERR_DEVICELOST == hr )
  1486.         m_bDeviceLost = true;
  1488.     return S_OK;
  1489. }
  1494. //-----------------------------------------------------------------------------
  1495. // Name: UpdateStats()
  1496. // Desc: 
  1497. //-----------------------------------------------------------------------------
  1498. void CD3DApplication::UpdateStats()
  1499. {
  1500.     // Keep track of the frame count
  1501.     static FLOAT fLastTime = 0.0f;
  1502.     static DWORD dwFrames  = 0;
  1503.     FLOAT fTime = DXUtil_Timer( TIMER_GETABSOLUTETIME );
  1504.     ++dwFrames;
  1506.     // Update the scene stats once per second
  1507.     if( fTime - fLastTime > 1.0f )
  1508.     {
  1509.         m_fFPS    = dwFrames / (fTime - fLastTime);
  1510.         fLastTime = fTime;
  1511.         dwFrames  = 0;
  1513.         TCHAR strFmt[100];
  1514.         D3DFORMAT fmtAdapter = m_d3dSettings.DisplayMode().Format;
  1515.         if( fmtAdapter == m_d3dsdBackBuffer.Format )
  1516.         {
  1517.             lstrcpyn( strFmt, D3DUtil_D3DFormatToString( fmtAdapter, false ), 100 );
  1518.         }
  1519.         else
  1520.         {
  1521.             _sntprintf( strFmt, 100, TEXT("backbuf %s, adapter %s"), 
  1522.                 D3DUtil_D3DFormatToString( m_d3dsdBackBuffer.Format, false ), 
  1523.                 D3DUtil_D3DFormatToString( fmtAdapter, false ) );
  1524.         }
  1525.         strFmt[99] = TEXT('');
  1527.         TCHAR strDepthFmt[100];
  1528.         if( m_d3dEnumeration.AppUsesDepthBuffer )
  1529.         {
  1530.             _sntprintf( strDepthFmt, 100, TEXT(" (%s)"), 
  1531.                 D3DUtil_D3DFormatToString( m_d3dSettings.DepthStencilBufferFormat(), false ) );
  1532.             strDepthFmt[99] = TEXT('');
  1533.         }
  1534.         else
  1535.         {
  1536.             // No depth buffer
  1537.             strDepthFmt[0] = TEXT('');
  1538.         }
  1540.         TCHAR* pstrMultiSample;
  1541.         switch( m_d3dSettings.MultisampleType() )
  1542.         {
  1543.         case D3DMULTISAMPLE_NONMASKABLE:  pstrMultiSample = TEXT(" (Nonmaskable Multisample)"); break;
  1544.         case D3DMULTISAMPLE_2_SAMPLES:  pstrMultiSample = TEXT(" (2x Multisample)"); break;
  1545.         case D3DMULTISAMPLE_3_SAMPLES:  pstrMultiSample = TEXT(" (3x Multisample)"); break;
  1546.         case D3DMULTISAMPLE_4_SAMPLES:  pstrMultiSample = TEXT(" (4x Multisample)"); break;
  1547.         case D3DMULTISAMPLE_5_SAMPLES:  pstrMultiSample = TEXT(" (5x Multisample)"); break;
  1548.         case D3DMULTISAMPLE_6_SAMPLES:  pstrMultiSample = TEXT(" (6x Multisample)"); break;
  1549.         case D3DMULTISAMPLE_7_SAMPLES:  pstrMultiSample = TEXT(" (7x Multisample)"); break;
  1550.         case D3DMULTISAMPLE_8_SAMPLES:  pstrMultiSample = TEXT(" (8x Multisample)"); break;
  1551.         case D3DMULTISAMPLE_9_SAMPLES:  pstrMultiSample = TEXT(" (9x Multisample)"); break;
  1552.         case D3DMULTISAMPLE_10_SAMPLES: pstrMultiSample = TEXT(" (10x Multisample)"); break;
  1553.         case D3DMULTISAMPLE_11_SAMPLES: pstrMultiSample = TEXT(" (11x Multisample)"); break;
  1554.         case D3DMULTISAMPLE_12_SAMPLES: pstrMultiSample = TEXT(" (12x Multisample)"); break;
  1555.         case D3DMULTISAMPLE_13_SAMPLES: pstrMultiSample = TEXT(" (13x Multisample)"); break;
  1556.         case D3DMULTISAMPLE_14_SAMPLES: pstrMultiSample = TEXT(" (14x Multisample)"); break;
  1557.         case D3DMULTISAMPLE_15_SAMPLES: pstrMultiSample = TEXT(" (15x Multisample)"); break;
  1558.         case D3DMULTISAMPLE_16_SAMPLES: pstrMultiSample = TEXT(" (16x Multisample)"); break;
  1559.         default:                        pstrMultiSample = TEXT(""); break;
  1560.         }
  1562.         const int cchMaxFrameStats = sizeof(m_strFrameStats) / sizeof(TCHAR);
  1563.         _sntprintf( m_strFrameStats, cchMaxFrameStats, _T("%.02f fps (%dx%d), %s%s%s"), m_fFPS,
  1564.                     m_d3dsdBackBuffer.Width, m_d3dsdBackBuffer.Height,
  1565.                     strFmt, strDepthFmt, pstrMultiSample );
  1566.         m_strFrameStats[cchMaxFrameStats - 1] = TEXT('');
  1567.     }
  1568. }
  1573. //-----------------------------------------------------------------------------
  1574. // Name: Pause()
  1575. // Desc: Called in to toggle the pause state of the app.
  1576. //-----------------------------------------------------------------------------
  1577. void CD3DApplication::Pause( bool bPause )
  1578. {
  1579.     static DWORD dwAppPausedCount = 0;
  1581.     dwAppPausedCount += ( bPause ? +1 : -1 );
  1582.     m_bActive         = ( dwAppPausedCount ? false : true );
  1584.     // Handle the first pause request (of many, nestable pause requests)
  1585.     if( bPause && ( 1 == dwAppPausedCount ) )
  1586.     {
  1587.         // Stop the scene from animating
  1588.         if( m_bFrameMoving )
  1589.             DXUtil_Timer( TIMER_STOP );
  1590.     }
  1592.     if( 0 == dwAppPausedCount )
  1593.     {
  1594.         // Restart the timers
  1595.         if( m_bFrameMoving )
  1596.             DXUtil_Timer( TIMER_START );
  1597.     }
  1598. }
  1603. //-----------------------------------------------------------------------------
  1604. // Name: Cleanup3DEnvironment()
  1605. // Desc: Cleanup scene objects
  1606. //-----------------------------------------------------------------------------
  1607. void CD3DApplication::Cleanup3DEnvironment()
  1608. {
  1609.     if( m_pd3dDevice != NULL )
  1610.     {
  1611.         if( m_bDeviceObjectsRestored )
  1612.         {
  1613.             m_bDeviceObjectsRestored = false;
  1614.             InvalidateDeviceObjects();
  1615.         }
  1616.         if( m_bDeviceObjectsInited )
  1617.         {
  1618.             m_bDeviceObjectsInited = false;
  1619.             DeleteDeviceObjects();
  1620.         }
  1622.         if( m_pd3dDevice->Release() > 0 )
  1623.             DisplayErrorMsg( D3DAPPERR_NONZEROREFCOUNT, MSGERR_APPMUSTEXIT );
  1624.         m_pd3dDevice = NULL;
  1625.     }
  1626. }
  1631. //-----------------------------------------------------------------------------
  1632. // Name: DisplayErrorMsg()
  1633. // Desc: Displays error messages in a message box
  1634. //-----------------------------------------------------------------------------
  1635. HRESULT CD3DApplication::DisplayErrorMsg( HRESULT hr, DWORD dwType )
  1636. {
  1637.     static bool s_bFatalErrorReported = false;
  1638.     TCHAR strMsg[512];
  1640.     // If a fatal error message has already been reported, the app
  1641.     // is already shutting down, so don't show more error messages.
  1642.     if( s_bFatalErrorReported )
  1643.         return hr;
  1645.     switch( hr )
  1646.     {
  1647.         case D3DAPPERR_NODIRECT3D:
  1648.             _tcscpy( strMsg, _T("Could not initialize Direct3D. You mayn")
  1649.                              _T("want to check that the latest version ofn")
  1650.                              _T("DirectX is correctly installed on yourn")
  1651.                              _T("system.  Also make sure that this programn")
  1652.                              _T("was compiled with header files that matchn")
  1653.                              _T("the installed DirectX DLLs.") );
  1654.             break;
  1656.         case D3DAPPERR_NOCOMPATIBLEDEVICES:
  1657.             _tcscpy( strMsg, _T("Could not find any compatible Direct3Dn")
  1658.                              _T("devices.") );
  1659.             break;
  1661.         case D3DAPPERR_NOWINDOWABLEDEVICES:
  1662.             _tcscpy( strMsg, _T("This sample cannot run in a desktopn")
  1663.                              _T("window with the current display settings.n")
  1664.                              _T("Please change your desktop settings to an")
  1665.                              _T("16- or 32-bit display mode and re-run thisn")
  1666.                              _T("sample.") );
  1667.             break;
  1669.         case D3DAPPERR_NOHARDWAREDEVICE:
  1670.             _tcscpy( strMsg, _T("No hardware-accelerated Direct3D devicesn")
  1671.                              _T("were found.") );
  1672.             break;
  1674.         case D3DAPPERR_HALNOTCOMPATIBLE:
  1675.             _tcscpy( strMsg, _T("This sample requires functionality that isn")
  1676.                              _T("not available on your Direct3D hardwaren")
  1677.                              _T("accelerator.") );
  1678.             break;
  1680.         case D3DAPPERR_NOWINDOWEDHAL:
  1681.             _tcscpy( strMsg, _T("Your Direct3D hardware accelerator cannotn")
  1682.                              _T("render into a window.n")
  1683.                              _T("Press F2 while the app is running to see an")
  1684.                              _T("list of available devices and modes.") );
  1685.             break;
  1687.         case D3DAPPERR_NODESKTOPHAL:
  1688.             _tcscpy( strMsg, _T("Your Direct3D hardware accelerator cannotn")
  1689.                              _T("render into a window with the currentn")
  1690.                              _T("desktop display settings.n")
  1691.                              _T("Press F2 while the app is running to see an")
  1692.                              _T("list of available devices and modes.") );
  1693.             break;
  1695.         case D3DAPPERR_NOHALTHISMODE:
  1696.             _tcscpy( strMsg, _T("This sample requires functionality that isn")
  1697.                              _T("not available on your Direct3D hardwaren")
  1698.                              _T("accelerator with the current desktop displayn")
  1699.                              _T("settings.n")
  1700.                              _T("Press F2 while the app is running to see an")
  1701.                              _T("list of available devices and modes.") );
  1702.             break;
  1704.         case D3DAPPERR_MEDIANOTFOUND:
  1705.         case 0x80070002: // HRESULT_FROM_WIN32( ERROR_FILE_NOT_FOUND ):
  1706.             _tcscpy( strMsg, _T("Could not load required media." ) );
  1707.             break;
  1709.         case D3DAPPERR_RESETFAILED:
  1710.             _tcscpy( strMsg, _T("Could not reset the Direct3D device." ) );
  1711.             break;
  1713.         case D3DAPPERR_NONZEROREFCOUNT:
  1714.             _tcscpy( strMsg, _T("A D3D object has a non-zero referencen")
  1715.                              _T("count (meaning things were not properlyn")
  1716.                              _T("cleaned up).") );
  1717.             break;
  1719.         case D3DAPPERR_NULLREFDEVICE:
  1720.             _tcscpy( strMsg, _T("Warning: Nothing will be rendered.n")
  1721.                              _T("The reference rendering device was selected, but yourn")
  1722.                              _T("computer only has a reduced-functionality reference devicen")
  1723.                              _T("installed.  Install the DirectX SDK to get the fulln")
  1724.                              _T("reference device.n") );
  1725.             break;
  1727.         case E_OUTOFMEMORY:
  1728.             _tcscpy( strMsg, _T("Not enough memory.") );
  1729.             break;
  1731.         case D3DERR_OUTOFVIDEOMEMORY:
  1732.             _tcscpy( strMsg, _T("Not enough video memory.") );
  1733.             break;
  1735.         case D3DERR_DRIVERINTERNALERROR:
  1736.             _tcscpy( strMsg, _T("A serious problem occured inside the display driver.") );
  1737.             dwType = MSGERR_APPMUSTEXIT;
  1738.             break;
  1740.         default:
  1741.             _tcscpy( strMsg, _T("Generic application error. Enablen")
  1742.                              _T("debug output for detailed information.") );
  1743.     }
  1745.     if( MSGERR_APPMUSTEXIT == dwType )
  1746.     {
  1747.         s_bFatalErrorReported = true;
  1748.         _tcscat( strMsg, _T("nnThis sample will now exit.") );
  1749.         MessageBox( NULL, strMsg, m_strWindowTitle, MB_ICONERROR|MB_OK );
  1751.         // Close the window, which shuts down the app
  1752.         if( m_hWnd )
  1753.             SendMessage( m_hWnd, WM_CLOSE, 0, 0 );
  1754.     }
  1755.     else
  1756.     {
  1757.         if( MSGWARN_SWITCHEDTOREF == dwType )
  1758.             _tcscat( strMsg, _T("nnSwitching to the reference rasterizer,n")
  1759.                              _T("a software device that implements the entiren")
  1760.                              _T("Direct3D feature set, but runs very slowly.") );
  1761.         MessageBox( NULL, strMsg, m_strWindowTitle, MB_ICONWARNING|MB_OK );
  1762.     }
  1764.     return hr;
  1765. }
  1770. //-----------------------------------------------------------------------------
  1771. // Name: LaunchReadme()
  1772. // Desc: Ensures the app is windowed, and launches the readme.txt 
  1773. //       in the default text editor
  1774. //-----------------------------------------------------------------------------
  1775. HRESULT CD3DApplication::LaunchReadme()
  1776. {
  1777.     // Switch to windowed if launching the readme.txt
  1778.     if( m_bWindowed == false )
  1779.     {
  1780.         if( FAILED( ToggleFullscreen() ) )
  1781.         {
  1782.             DisplayErrorMsg( D3DAPPERR_RESETFAILED, MSGERR_APPMUSTEXIT );
  1783.             return E_FAIL;
  1784.         }
  1785.     }
  1787.     DXUtil_LaunchReadme( m_hWnd );
  1789.     return S_OK;
  1790. }