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

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

游戏

开发平台：

Visual C++

d3dsettings.cpp：源码内容
  1. //-----------------------------------------------------------------------------
  2. // File: D3DSettings.cpp
  3. //
  4. // Desc: Settings class and change-settings dialog class for the Direct3D 
  5. //       samples framework library.
  6. //
  7. // Copyright (c) Microsoft Corporation. All rights reserved.
  8. //-----------------------------------------------------------------------------
  9. #include "dxstdafx.h"
  11. CD3DSettingsDialog* s_pSettingsDialog = NULL;
  14. //-----------------------------------------------------------------------------
  15. // Name: D3DDevTypeToString
  16. // Desc: Returns the string for the given D3DDEVTYPE.
  17. //-----------------------------------------------------------------------------
  18. TCHAR* D3DDevTypeToString(D3DDEVTYPE devType)
  19. {
  20.     switch (devType)
  21.     {
  22.     case D3DDEVTYPE_HAL:        return TEXT("D3DDEVTYPE_HAL");
  23.     case D3DDEVTYPE_SW:         return TEXT("D3DDEVTYPE_SW");
  24.     case D3DDEVTYPE_REF:        return TEXT("D3DDEVTYPE_REF");
  25.     default:                    return TEXT("Unknown devType");
  26.     }
  27. }
  30. //-----------------------------------------------------------------------------
  31. // Name: MultisampleTypeToString
  32. // Desc: Returns the string for the given D3DMULTISAMPLE_TYPE.
  33. //-----------------------------------------------------------------------------
  34. TCHAR* MultisampleTypeToString(D3DMULTISAMPLE_TYPE MultiSampleType)
  35. {
  36.     switch (MultiSampleType)
  37.     {
  38.     case D3DMULTISAMPLE_NONE:   return TEXT("D3DMULTISAMPLE_NONE");
  39.     case D3DMULTISAMPLE_NONMASKABLE: return TEXT("D3DMULTISAMPLE_NONMASKABLE");
  40.     case D3DMULTISAMPLE_2_SAMPLES: return TEXT("D3DMULTISAMPLE_2_SAMPLES");
  41.     case D3DMULTISAMPLE_3_SAMPLES: return TEXT("D3DMULTISAMPLE_3_SAMPLES");
  42.     case D3DMULTISAMPLE_4_SAMPLES: return TEXT("D3DMULTISAMPLE_4_SAMPLES");
  43.     case D3DMULTISAMPLE_5_SAMPLES: return TEXT("D3DMULTISAMPLE_5_SAMPLES");
  44.     case D3DMULTISAMPLE_6_SAMPLES: return TEXT("D3DMULTISAMPLE_6_SAMPLES");
  45.     case D3DMULTISAMPLE_7_SAMPLES: return TEXT("D3DMULTISAMPLE_7_SAMPLES");
  46.     case D3DMULTISAMPLE_8_SAMPLES: return TEXT("D3DMULTISAMPLE_8_SAMPLES");
  47.     case D3DMULTISAMPLE_9_SAMPLES: return TEXT("D3DMULTISAMPLE_9_SAMPLES");
  48.     case D3DMULTISAMPLE_10_SAMPLES: return TEXT("D3DMULTISAMPLE_10_SAMPLES");
  49.     case D3DMULTISAMPLE_11_SAMPLES: return TEXT("D3DMULTISAMPLE_11_SAMPLES");
  50.     case D3DMULTISAMPLE_12_SAMPLES: return TEXT("D3DMULTISAMPLE_12_SAMPLES");
  51.     case D3DMULTISAMPLE_13_SAMPLES: return TEXT("D3DMULTISAMPLE_13_SAMPLES");
  52.     case D3DMULTISAMPLE_14_SAMPLES: return TEXT("D3DMULTISAMPLE_14_SAMPLES");
  53.     case D3DMULTISAMPLE_15_SAMPLES: return TEXT("D3DMULTISAMPLE_15_SAMPLES");
  54.     case D3DMULTISAMPLE_16_SAMPLES: return TEXT("D3DMULTISAMPLE_16_SAMPLES");
  55.     default:                    return TEXT("Unknown Multisample Type");
  56.     }
  57. }
  60. //-----------------------------------------------------------------------------
  61. // Name: VertexProcessingTypeToString
  62. // Desc: Returns the string for the given VertexProcessingType.
  63. //-----------------------------------------------------------------------------
  64. TCHAR* VertexProcessingTypeToString(VertexProcessingType vpt)
  65. {
  66.     switch (vpt)
  67.     {
  68.     case SOFTWARE_VP:      return TEXT("SOFTWARE_VP");
  69.     case MIXED_VP:         return TEXT("MIXED_VP");
  70.     case HARDWARE_VP:      return TEXT("HARDWARE_VP");
  71.     case PURE_HARDWARE_VP: return TEXT("PURE_HARDWARE_VP");
  72.     default:               return TEXT("Unknown VertexProcessingType");
  73.     }
  74. }
  77. //-----------------------------------------------------------------------------
  78. // Name: PresentIntervalToString
  79. // Desc: Returns the string for the given present interval.
  80. //-----------------------------------------------------------------------------
  81. TCHAR* PresentIntervalToString( UINT pi )
  82. {
  83.     switch( pi )
  84.     {
  85.     case D3DPRESENT_INTERVAL_IMMEDIATE: return TEXT("D3DPRESENT_INTERVAL_IMMEDIATE");
  86.     case D3DPRESENT_INTERVAL_DEFAULT:   return TEXT("D3DPRESENT_INTERVAL_DEFAULT");
  87.     case D3DPRESENT_INTERVAL_ONE:       return TEXT("D3DPRESENT_INTERVAL_ONE");
  88.     case D3DPRESENT_INTERVAL_TWO:       return TEXT("D3DPRESENT_INTERVAL_TWO");
  89.     case D3DPRESENT_INTERVAL_THREE:     return TEXT("D3DPRESENT_INTERVAL_THREE");
  90.     case D3DPRESENT_INTERVAL_FOUR:      return TEXT("D3DPRESENT_INTERVAL_FOUR");
  91.     default:                            return TEXT("Unknown PresentInterval");
  92.     }
  93. }
  98. //-----------------------------------------------------------------------------
  99. // Name: DialogProcHelper
  100. // Desc: 
  101. //-----------------------------------------------------------------------------
  102. INT_PTR CALLBACK DialogProcHelper( HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam )
  103. {
  104.     return s_pSettingsDialog->DialogProc( hDlg, msg, wParam, lParam );
  105. }
  110. //-----------------------------------------------------------------------------
  111. // Name: CD3DSettingsDialog constructor
  112. // Desc: 
  113. //-----------------------------------------------------------------------------
  114. CD3DSettingsDialog::CD3DSettingsDialog( CD3DEnumeration* pEnumeration, 
  115.                                         CD3DSettings* pSettings)
  116. {
  117.     s_pSettingsDialog = this;
  118.     m_pEnumeration = pEnumeration;
  119.     m_d3dSettings = *pSettings;
  120. }
  125. //-----------------------------------------------------------------------------
  126. // Name: ComboBoxAdd
  127. // Desc: Adds an entry to the combo box.
  128. //-----------------------------------------------------------------------------
  129. void CD3DSettingsDialog::ComboBoxAdd( int id, void* pData, LPCTSTR pstrDesc )
  130. {
  131.     HWND hwndCtrl = GetDlgItem( m_hDlg, id );
  132.     DWORD dwItem = ComboBox_AddString( hwndCtrl, pstrDesc );
  133.     ComboBox_SetItemData( hwndCtrl, dwItem, pData );
  134. }
  139. //-----------------------------------------------------------------------------
  140. // Name: ComboBoxSelect
  141. // Desc: Selects an entry in the combo box.
  142. //-----------------------------------------------------------------------------
  143. void CD3DSettingsDialog::ComboBoxSelect( int id, void* pData )
  144. {
  145.     HWND hwndCtrl = GetDlgItem( m_hDlg, id );
  146.     UINT count = ComboBoxCount( id );
  147.     for( UINT iItem = 0; iItem < count; iItem++ )
  148.     {
  149.         if( (void*)ComboBox_GetItemData( hwndCtrl, iItem ) == pData )
  150.         {
  151.             ComboBox_SetCurSel( hwndCtrl, iItem );
  152.             PostMessage( m_hDlg, WM_COMMAND, 
  153.                 MAKEWPARAM( id, CBN_SELCHANGE ), (LPARAM)hwndCtrl );
  154.             return;
  155.         }
  156.     }
  157. }
  162. //-----------------------------------------------------------------------------
  163. // Name: ComboBoxSelectIndex
  164. // Desc: Selects an entry in the combo box.
  165. //-----------------------------------------------------------------------------
  166. void CD3DSettingsDialog::ComboBoxSelectIndex( int id, int index )
  167. {
  168.     HWND hwndCtrl = GetDlgItem( m_hDlg, id );
  169.     ComboBox_SetCurSel( hwndCtrl, index );
  170.     PostMessage( m_hDlg, WM_COMMAND, MAKEWPARAM( id, CBN_SELCHANGE ), 
  171.         (LPARAM)hwndCtrl );
  172. }
  177. //-----------------------------------------------------------------------------
  178. // Name: ComboBoxSelected
  179. // Desc: Returns the data for the selected entry in the combo box.
  180. //-----------------------------------------------------------------------------
  181. void* CD3DSettingsDialog::ComboBoxSelected( int id )
  182. {
  183.     HWND hwndCtrl = GetDlgItem( m_hDlg, id );
  184.     int index = ComboBox_GetCurSel( hwndCtrl );
  185.     if( index < 0 )
  186.         return NULL;
  187.     return (void*)ComboBox_GetItemData( hwndCtrl, index );
  188. }
  193. //-----------------------------------------------------------------------------
  194. // Name: ComboBoxSomethingSelected
  195. // Desc: Returns whether any entry in the combo box is selected.  This is 
  196. //       more useful than ComboBoxSelected() when you need to distinguish 
  197. //       between having no item selected vs. having an item selected whose 
  198. //       itemData is NULL.
  199. //-----------------------------------------------------------------------------
  200. bool CD3DSettingsDialog::ComboBoxSomethingSelected( int id )
  201. {
  202.     HWND hwndCtrl = GetDlgItem( m_hDlg, id );
  203.     int index = ComboBox_GetCurSel( hwndCtrl );
  204.     return ( index >= 0 );
  205. }
  210. //-----------------------------------------------------------------------------
  211. // Name: ComboBoxCount
  212. // Desc: Returns the number of entries in the combo box.
  213. //-----------------------------------------------------------------------------
  214. UINT CD3DSettingsDialog::ComboBoxCount( int id )
  215. {
  216.     HWND hwndCtrl = GetDlgItem( m_hDlg, id );
  217.     return ComboBox_GetCount( hwndCtrl );
  218. }
  223. //-----------------------------------------------------------------------------
  224. // Name: ComboBoxClear
  225. // Desc: Clears the entries in the combo box.
  226. //-----------------------------------------------------------------------------
  227. void CD3DSettingsDialog::ComboBoxClear( int id )
  228. {
  229.     HWND hwndCtrl = GetDlgItem( m_hDlg, id );
  230.     ComboBox_ResetContent( hwndCtrl );
  231. }
  236. //-----------------------------------------------------------------------------
  237. // Name: ComboBoxContainsText
  238. // Desc: Returns whether the combo box contains the given text.
  239. //-----------------------------------------------------------------------------
  240. bool CD3DSettingsDialog::ComboBoxContainsText( int id, LPCTSTR pstrText )
  241. {
  242.     TCHAR strItem[200];
  243.     HWND hwndCtrl = GetDlgItem( m_hDlg, id );
  244.     UINT count = ComboBoxCount( id );
  245.     for( UINT iItem = 0; iItem < count; iItem++ )
  246.     {
  247.         if( ComboBox_GetLBTextLen( hwndCtrl, iItem ) >= 200 )
  248.             continue; // shouldn't happen, but don't overwrite buffer if it does
  249.         ComboBox_GetLBText( hwndCtrl, iItem, strItem );
  250.         if( lstrcmp( strItem, pstrText ) == 0 )
  251.             return true;
  252.     }
  253.     return false;
  254. }
  259. //-----------------------------------------------------------------------------
  260. // Name: ShowDialog
  261. // Desc: Show the D3D settings dialog.
  262. //-----------------------------------------------------------------------------
  263. INT_PTR CD3DSettingsDialog::ShowDialog( HWND hwndParent )
  264. {
  265.     return DialogBox( NULL, MAKEINTRESOURCE( IDD_SELECTDEVICE ), 
  266.         hwndParent, DialogProcHelper );
  267. }
  272. //-----------------------------------------------------------------------------
  273. // Name: DialogProc
  274. // Desc: Handle window messages in the dialog.
  275. //-----------------------------------------------------------------------------
  276. INT_PTR CD3DSettingsDialog::DialogProc( HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam )
  277. {
  278.     UNREFERENCED_PARAMETER( lParam );
  280.     switch( msg )
  281.     {
  282.     case WM_INITDIALOG:
  283.         {
  284.             m_hDlg = hDlg;
  286.             // Fill adapter combo box.  Updating the selected adapter will trigger
  287.             // updates of the rest of the dialog.
  288.             for( UINT iai = 0; iai < m_pEnumeration->m_pAdapterInfoList->Count(); iai++ )
  289.             {
  290.                 D3DAdapterInfo* pAdapterInfo;
  291.                 pAdapterInfo = (D3DAdapterInfo*)m_pEnumeration->m_pAdapterInfoList->GetPtr(iai);
  292.                 TCHAR strDescription[512];
  293.                 DXUtil_ConvertAnsiStringToGenericCch( strDescription, pAdapterInfo->AdapterIdentifier.Description, 512 );
  294.                 ComboBoxAdd( IDC_ADAPTER_COMBO, pAdapterInfo, strDescription );
  295.                 if( pAdapterInfo->AdapterOrdinal == m_d3dSettings.AdapterOrdinal() )
  296.                     ComboBoxSelect( IDC_ADAPTER_COMBO, pAdapterInfo );
  297.             }
  298.             if( !ComboBoxSomethingSelected( IDC_ADAPTER_COMBO ) &&
  299.                 ComboBoxCount( IDC_ADAPTER_COMBO ) > 0 )
  300.             {
  301.                 ComboBoxSelectIndex( IDC_ADAPTER_COMBO, 0 );
  302.             }
  303.         }
  304.         return TRUE;
  306.     case WM_COMMAND:
  307.         switch( LOWORD(wParam) )
  308.         {
  309.         case IDOK:
  310.             EndDialog( hDlg, IDOK );
  311.             break;
  312.         case IDCANCEL:
  313.             EndDialog( hDlg, IDCANCEL );
  314.             break;
  315.         case IDC_ADAPTER_COMBO:
  316.             if( CBN_SELCHANGE == HIWORD(wParam) )
  317.                 AdapterChanged();
  318.             break;
  319.         case IDC_DEVICE_COMBO:
  320.             if( CBN_SELCHANGE == HIWORD(wParam) )
  321.                 DeviceChanged();
  322.             break;
  323.         case IDC_ADAPTERFORMAT_COMBO:
  324.             if( CBN_SELCHANGE == HIWORD(wParam) )
  325.                 AdapterFormatChanged();
  326.             break;
  327.         case IDC_RESOLUTION_COMBO:
  328.             if( CBN_SELCHANGE == HIWORD(wParam) )
  329.                 ResolutionChanged();
  330.             break;
  331.         case IDC_REFRESHRATE_COMBO:
  332.             if( CBN_SELCHANGE == HIWORD(wParam) )
  333.                 RefreshRateChanged();
  334.             break;
  335.         case IDC_BACKBUFFERFORMAT_COMBO:
  336.             if( CBN_SELCHANGE == HIWORD(wParam) )
  337.                 BackBufferFormatChanged();
  338.             break;
  339.         case IDC_DEPTHSTENCILBUFFERFORMAT_COMBO:
  340.             if( CBN_SELCHANGE == HIWORD(wParam) )
  341.                 DepthStencilBufferFormatChanged();
  342.             break;
  343.         case IDC_MULTISAMPLE_COMBO:
  344.             if( CBN_SELCHANGE == HIWORD(wParam) )
  345.                 MultisampleTypeChanged();
  346.             break;
  347.         case IDC_MULTISAMPLE_QUALITY_COMBO:
  348.             if( CBN_SELCHANGE == HIWORD(wParam) )
  349.                 MultisampleQualityChanged();
  350.             break;
  351.         case IDC_VERTEXPROCESSING_COMBO:
  352.             if( CBN_SELCHANGE == HIWORD(wParam) )
  353.                 VertexProcessingChanged();
  354.             break;
  355.         case IDC_PRESENTINTERVAL_COMBO:
  356.             if( CBN_SELCHANGE == HIWORD(wParam) )
  357.                 PresentIntervalChanged();
  358.             break;
  359.         case IDC_DEVICECLIP_CHECK:
  360.             if( BN_CLICKED == HIWORD(wParam) )
  361.                 DeviceClipChanged();
  362.             break;
  363.         case IDC_WINDOW:
  364.         case IDC_FULLSCREEN:
  365.             WindowedFullscreenChanged();
  366.             break;
  367.         }
  368.         return TRUE;
  370.     default:
  371.         return FALSE;
  372.     }
  373. }
  377. //-----------------------------------------------------------------------------
  378. // Name: AdapterChanged
  379. // Desc: Respond to a change of selected adapter.
  380. //-----------------------------------------------------------------------------
  381. void CD3DSettingsDialog::AdapterChanged( void )
  382. {
  383.     D3DAdapterInfo* pAdapterInfo = (D3DAdapterInfo*)ComboBoxSelected( IDC_ADAPTER_COMBO );
  384.     if( pAdapterInfo == NULL )
  385.         return;
  386.     
  387.     if( m_d3dSettings.IsWindowed )
  388.     {
  389.         m_d3dSettings.pWindowed_AdapterInfo = pAdapterInfo;
  391.         // Set the windowed display mode format to what the
  392.         // adapter is currently in.
  393.         IDirect3D9* pD3D = m_pEnumeration->GetD3D();
  394.         if( pD3D )
  395.         {
  396.             D3DDISPLAYMODE Mode;
  397.             if( SUCCEEDED( pD3D->GetAdapterDisplayMode( pAdapterInfo->AdapterOrdinal, &Mode ) ) )
  398.                 m_d3dSettings.Windowed_DisplayMode.Format = Mode.Format;
  399.             SAFE_RELEASE( pD3D );
  400.         }
  401.     }
  402.     else
  403.         m_d3dSettings.pFullscreen_AdapterInfo = pAdapterInfo;
  405.     // Update device combo box
  406.     ComboBoxClear( IDC_DEVICE_COMBO );
  407.     for( UINT idi = 0; idi < pAdapterInfo->pDeviceInfoList->Count(); idi++ )
  408.     {
  409.         D3DDeviceInfo* pDeviceInfo = (D3DDeviceInfo*)pAdapterInfo->pDeviceInfoList->GetPtr(idi);
  410.         ComboBoxAdd( IDC_DEVICE_COMBO, pDeviceInfo, 
  411.                      D3DDevTypeToString( pDeviceInfo->DevType ) );
  412.         if( pDeviceInfo->DevType == m_d3dSettings.DevType() )
  413.             ComboBoxSelect( IDC_DEVICE_COMBO, pDeviceInfo );
  414.     }
  415.     if( !ComboBoxSomethingSelected( IDC_DEVICE_COMBO ) &&
  416.         ComboBoxCount( IDC_DEVICE_COMBO ) > 0 )
  417.     {
  418.         ComboBoxSelectIndex( IDC_DEVICE_COMBO, 0 );
  419.     }
  420. }
  425. //-----------------------------------------------------------------------------
  426. // Name: DeviceChanged
  427. // Desc: Respond to a change of selected device by resetting the 
  428. //       fullscreen/windowed radio buttons.  Updating these buttons will 
  429. //       trigger updates of the rest of the dialog.
  430. //-----------------------------------------------------------------------------
  431. void CD3DSettingsDialog::DeviceChanged( void )
  432. {
  433.     D3DDeviceInfo* pDeviceInfo = (D3DDeviceInfo*)ComboBoxSelected( IDC_DEVICE_COMBO );
  434.     if( pDeviceInfo == NULL )
  435.         return;
  437.     if( m_d3dSettings.IsWindowed )
  438.         m_d3dSettings.pWindowed_DeviceInfo = pDeviceInfo;
  439.     else
  440.         m_d3dSettings.pFullscreen_DeviceInfo = pDeviceInfo;
  442.     // Update fullscreen/windowed radio buttons
  443.     bool HasWindowedDeviceCombo = false;
  444.     bool HasFullscreenDeviceCombo = false;
  445.     for( UINT idc = 0; idc < pDeviceInfo->pDeviceComboList->Count(); idc++ )
  446.     {
  447.         D3DDeviceCombo* pDeviceCombo = (D3DDeviceCombo*)pDeviceInfo->pDeviceComboList->GetPtr(idc);
  448.         if( pDeviceCombo->IsWindowed )
  449.             HasWindowedDeviceCombo = true;
  450.         else
  451.             HasFullscreenDeviceCombo = true;
  452.     }
  453.     EnableWindow( GetDlgItem( m_hDlg, IDC_WINDOW ), HasWindowedDeviceCombo );
  454.     EnableWindow( GetDlgItem( m_hDlg, IDC_FULLSCREEN ), HasFullscreenDeviceCombo );
  455.     if (m_d3dSettings.IsWindowed && HasWindowedDeviceCombo)
  456.     {
  457.         CheckRadioButton( m_hDlg, IDC_WINDOW, IDC_FULLSCREEN, IDC_WINDOW );
  458.     }
  459.     else
  460.     {
  461.         CheckRadioButton( m_hDlg, IDC_WINDOW, IDC_FULLSCREEN, IDC_FULLSCREEN );
  462.     }
  463.     WindowedFullscreenChanged();
  464. }
  469. //-----------------------------------------------------------------------------
  470. // Name: WindowedFullscreenChanged
  471. // Desc: Respond to a change of windowed/fullscreen state by rebuilding the
  472. //       adapter format list, resolution list, and refresh rate list.
  473. //       Updating the selected adapter format will trigger updates of the 
  474. //       rest of the dialog.
  475. //-----------------------------------------------------------------------------
  476. void CD3DSettingsDialog::WindowedFullscreenChanged( void )
  477. {
  478.     D3DAdapterInfo* pAdapterInfo = (D3DAdapterInfo*)ComboBoxSelected( IDC_ADAPTER_COMBO );
  479.     D3DDeviceInfo* pDeviceInfo = (D3DDeviceInfo*)ComboBoxSelected( IDC_DEVICE_COMBO );
  480.     if( pAdapterInfo == NULL || pDeviceInfo == NULL )
  481.         return;
  483.     if( IsDlgButtonChecked( m_hDlg, IDC_WINDOW ) )
  484.     {
  485.         m_d3dSettings.IsWindowed = true;
  486.         m_d3dSettings.pWindowed_AdapterInfo = pAdapterInfo;
  487.         m_d3dSettings.pWindowed_DeviceInfo = pDeviceInfo;
  489.         // Update device clip check box
  490.         EnableWindow( GetDlgItem( m_hDlg, IDC_DEVICECLIP_CHECK ), true );
  491.         if( m_d3dSettings.DeviceClip() )
  492.             SendMessage( GetDlgItem( m_hDlg, IDC_DEVICECLIP_CHECK ), BM_SETCHECK, BST_CHECKED, 0 );
  493.         else
  494.             SendMessage( GetDlgItem( m_hDlg, IDC_DEVICECLIP_CHECK ), BM_SETCHECK, BST_UNCHECKED, 0 );
  496.         // Update adapter format combo box
  497.         ComboBoxClear( IDC_ADAPTERFORMAT_COMBO );
  498.         ComboBoxAdd( IDC_ADAPTERFORMAT_COMBO, (void*)m_d3dSettings.Windowed_DisplayMode.Format,
  499.             D3DUtil_D3DFormatToString( m_d3dSettings.Windowed_DisplayMode.Format ) );
  500.         ComboBoxSelectIndex( IDC_ADAPTERFORMAT_COMBO, 0 );
  501.         EnableWindow( GetDlgItem( m_hDlg, IDC_ADAPTERFORMAT_COMBO ), false );
  503.         // Update resolution combo box
  504.         DWORD dwResolutionData;
  505.         TCHAR strResolution[50];
  506.         dwResolutionData = MAKELONG( m_d3dSettings.Windowed_DisplayMode.Width,
  507.                                      m_d3dSettings.Windowed_DisplayMode.Height );
  508.         _sntprintf( strResolution, 50, TEXT("%d by %d"), m_d3dSettings.Windowed_DisplayMode.Width, 
  509.             m_d3dSettings.Windowed_DisplayMode.Height );
  510.         strResolution[49] = 0;
  511.         ComboBoxClear( IDC_RESOLUTION_COMBO );
  512.         ComboBoxAdd( IDC_RESOLUTION_COMBO, ULongToPtr(dwResolutionData), strResolution );
  513.         ComboBoxSelectIndex( IDC_RESOLUTION_COMBO, 0 );
  514.         EnableWindow( GetDlgItem( m_hDlg, IDC_RESOLUTION_COMBO ), false );
  516.         // Update refresh rate combo box
  517.         TCHAR strRefreshRate[50];
  518.         if( m_d3dSettings.Windowed_DisplayMode.RefreshRate == 0 )
  519.             lstrcpy( strRefreshRate, TEXT("Default Rate") );
  520.         else
  521.             _sntprintf( strRefreshRate, 50, TEXT("%d Hz"), m_d3dSettings.Windowed_DisplayMode.RefreshRate );
  522.         strRefreshRate[49] = 0;
  523.         ComboBoxClear( IDC_REFRESHRATE_COMBO );
  524.         ComboBoxAdd( IDC_REFRESHRATE_COMBO, ULongToPtr(m_d3dSettings.Windowed_DisplayMode.RefreshRate),
  525.             strRefreshRate );
  526.         ComboBoxSelectIndex( IDC_REFRESHRATE_COMBO, 0 );
  527.         EnableWindow( GetDlgItem( m_hDlg, IDC_REFRESHRATE_COMBO ), false );
  528.     }
  529.     else
  530.     {
  531.         m_d3dSettings.IsWindowed = false;
  532.         m_d3dSettings.pFullscreen_AdapterInfo = pAdapterInfo;
  533.         m_d3dSettings.pFullscreen_DeviceInfo = pDeviceInfo;
  535.         // Update device clip check box
  536.         EnableWindow( GetDlgItem( m_hDlg, IDC_DEVICECLIP_CHECK ), false );
  538.         // Update adapter format combo box
  539.         ComboBoxClear( IDC_ADAPTERFORMAT_COMBO );
  540.         for( UINT idc = 0; idc < pDeviceInfo->pDeviceComboList->Count(); idc++ )
  541.         {
  542.             D3DDeviceCombo* pDeviceCombo = (D3DDeviceCombo*)pDeviceInfo->pDeviceComboList->GetPtr(idc);
  543.             if( pDeviceCombo->IsWindowed )
  544.                 continue;
  545.             D3DFORMAT adapterFormat = pDeviceCombo->AdapterFormat;
  546.             if( !ComboBoxContainsText( IDC_ADAPTERFORMAT_COMBO, D3DUtil_D3DFormatToString( adapterFormat ) ) )
  547.             {
  548.                 ComboBoxAdd( IDC_ADAPTERFORMAT_COMBO, (void*)adapterFormat, 
  549.                     D3DUtil_D3DFormatToString( adapterFormat ) );
  550.                 if( adapterFormat == m_d3dSettings.Fullscreen_DisplayMode.Format )
  551.                 {
  552.                     ComboBoxSelect( IDC_ADAPTERFORMAT_COMBO, (void*)adapterFormat );
  553.                 }
  554.             }
  555.         }
  556.         if( !ComboBoxSomethingSelected( IDC_ADAPTERFORMAT_COMBO ) &&
  557.             ComboBoxCount( IDC_ADAPTERFORMAT_COMBO ) > 0 )
  558.         {
  559.             ComboBoxSelectIndex( IDC_ADAPTERFORMAT_COMBO, 0 );
  560.         }
  561.         EnableWindow( GetDlgItem( m_hDlg, IDC_ADAPTERFORMAT_COMBO), true );
  562.         
  563.         // Update resolution combo box
  564.         EnableWindow( GetDlgItem( m_hDlg, IDC_RESOLUTION_COMBO), true );
  565.         
  566.         // Update refresh rate combo box
  567.         EnableWindow( GetDlgItem( m_hDlg, IDC_REFRESHRATE_COMBO), true );
  568.     }
  569. }
  574. //-----------------------------------------------------------------------------
  575. // Name: AdapterFormatChanged
  576. // Desc: Respond to a change of selected adapter format by rebuilding the
  577. //       resolution list and back buffer format list.  Updating the selected 
  578. //       resolution and back buffer format will trigger updates of the rest 
  579. //       of the dialog.
  580. //-----------------------------------------------------------------------------
  581. void CD3DSettingsDialog::AdapterFormatChanged( void )
  582. {
  583.     if( !IsDlgButtonChecked( m_hDlg, IDC_WINDOW ) )
  584.     {
  585.         D3DAdapterInfo* pAdapterInfo = (D3DAdapterInfo*)ComboBoxSelected( IDC_ADAPTER_COMBO );
  586.         D3DFORMAT adapterFormat = (D3DFORMAT)PtrToUlong( ComboBoxSelected( IDC_ADAPTERFORMAT_COMBO ) );
  587.         m_d3dSettings.Fullscreen_DisplayMode.Format = adapterFormat;
  589.         ComboBoxClear( IDC_RESOLUTION_COMBO );
  590.         for( UINT idm = 0; idm < pAdapterInfo->pDisplayModeList->Count(); idm++ )
  591.         {
  592.             D3DDISPLAYMODE displayMode = *(D3DDISPLAYMODE*)pAdapterInfo->pDisplayModeList->GetPtr(idm);
  593.             if (displayMode.Format == adapterFormat)
  594.             {
  595.                 DWORD dwResolutionData;
  596.                 TCHAR strResolution[50];
  597.                 dwResolutionData = MAKELONG( displayMode.Width, displayMode.Height );
  598.                 _sntprintf( strResolution, 50, TEXT("%d by %d"), displayMode.Width, displayMode.Height );
  599.                 strResolution[49] = 0;
  600.                 if (!ComboBoxContainsText( IDC_RESOLUTION_COMBO, strResolution ) )
  601.                 {
  602.                     ComboBoxAdd( IDC_RESOLUTION_COMBO, ULongToPtr( dwResolutionData ), strResolution );
  603.                     if (m_d3dSettings.Fullscreen_DisplayMode.Width == displayMode.Width &&
  604.                         m_d3dSettings.Fullscreen_DisplayMode.Height == displayMode.Height)
  605.                     {
  606.                         ComboBoxSelect( IDC_RESOLUTION_COMBO, ULongToPtr( dwResolutionData ) );
  607.                     }
  608.                 }
  609.             }
  610.         }
  611.         if (!ComboBoxSomethingSelected( IDC_RESOLUTION_COMBO ) && 
  612.             ComboBoxCount( IDC_RESOLUTION_COMBO ) > 0)
  613.         {
  614.             ComboBoxSelectIndex( IDC_RESOLUTION_COMBO, 0 );
  615.         }
  616.     }
  618.     // Update backbuffer format combo box
  619.     D3DDeviceInfo* pDeviceInfo = (D3DDeviceInfo*)ComboBoxSelected( IDC_DEVICE_COMBO );
  620.     if( pDeviceInfo == NULL )
  621.         return;
  622.     bool bHasWindowedBackbuffer = false;
  623.     ComboBoxClear( IDC_BACKBUFFERFORMAT_COMBO );
  624.     for( UINT idc = 0; idc < pDeviceInfo->pDeviceComboList->Count(); idc++ )
  625.     {
  626.         D3DDeviceCombo* pDeviceCombo = (D3DDeviceCombo*)pDeviceInfo->pDeviceComboList->GetPtr(idc);
  627.         if (pDeviceCombo->IsWindowed == m_d3dSettings.IsWindowed &&
  628.             pDeviceCombo->AdapterFormat == m_d3dSettings.DisplayMode().Format)
  629.         {
  630.             if (!ComboBoxContainsText( IDC_BACKBUFFERFORMAT_COMBO, 
  631.                 D3DUtil_D3DFormatToString( pDeviceCombo->BackBufferFormat ) ) )
  632.             {
  633.                 ComboBoxAdd( IDC_BACKBUFFERFORMAT_COMBO, (void*)pDeviceCombo->BackBufferFormat,
  634.                     D3DUtil_D3DFormatToString( pDeviceCombo->BackBufferFormat ) );
  635.                 if (pDeviceCombo->BackBufferFormat == m_d3dSettings.BackBufferFormat() )
  636.                     ComboBoxSelect( IDC_BACKBUFFERFORMAT_COMBO, (void*)pDeviceCombo->BackBufferFormat );
  637.             }
  638.         }
  640.         // Count the number of backbuffer format supported for windowed mode
  641.         if( true == pDeviceCombo->IsWindowed &&
  642.             pDeviceCombo->AdapterFormat == m_d3dSettings.Windowed_DisplayMode.Format )
  643.         {
  644.             bHasWindowedBackbuffer = true;
  645.         }
  646.     }
  648.     // If no backbuffer format is allowed and this is windowed, then the adapter
  649.     // cannot handle 3D in the format the desktop is currently in.  Force
  650.     // fullscreen in this case.
  651.     if( !bHasWindowedBackbuffer )
  652.     {
  653.         EnableWindow( GetDlgItem( m_hDlg, IDC_WINDOW ), FALSE );
  654.         if( m_d3dSettings.IsWindowed )
  655.         {
  656.             CheckRadioButton( m_hDlg, IDC_WINDOW, IDC_FULLSCREEN, IDC_FULLSCREEN );
  657.             WindowedFullscreenChanged();
  658.         }
  659.     }
  661.     if (!ComboBoxSomethingSelected( IDC_BACKBUFFERFORMAT_COMBO ) && 
  662.         ComboBoxCount( IDC_BACKBUFFERFORMAT_COMBO ) > 0)
  663.     {
  664.         ComboBoxSelectIndex( IDC_BACKBUFFERFORMAT_COMBO, 0 );
  665.     }
  666. }
  671. //-----------------------------------------------------------------------------
  672. // Name: ResolutionChanged
  673. // Desc: Respond to a change of selected resolution by rebuilding the
  674. //       refresh rate list.
  675. //-----------------------------------------------------------------------------
  676. void CD3DSettingsDialog::ResolutionChanged( void )
  677. {
  678.     if (m_d3dSettings.IsWindowed)
  679.         return;
  681.     D3DAdapterInfo* pAdapterInfo = (D3DAdapterInfo*)ComboBoxSelected( IDC_ADAPTER_COMBO );
  682.     if( pAdapterInfo == NULL )
  683.         return;
  685.     // Update settingsNew with new resolution
  686.     DWORD dwResolutionData = PtrToUlong( ComboBoxSelected( IDC_RESOLUTION_COMBO ) );
  687.     UINT width = LOWORD( dwResolutionData );
  688.     UINT height = HIWORD( dwResolutionData );
  689.     m_d3dSettings.Fullscreen_DisplayMode.Width = width;
  690.     m_d3dSettings.Fullscreen_DisplayMode.Height = height;
  692.     // Update refresh rate list based on new resolution
  693.     D3DFORMAT adapterFormat = (D3DFORMAT)PtrToUlong( ComboBoxSelected( IDC_ADAPTERFORMAT_COMBO ) );
  694.     ComboBoxClear( IDC_REFRESHRATE_COMBO );
  695.     for( UINT idm = 0; idm < pAdapterInfo->pDisplayModeList->Count(); idm++ )
  696.     {
  697.         D3DDISPLAYMODE displayMode = *(D3DDISPLAYMODE*)pAdapterInfo->pDisplayModeList->GetPtr(idm);
  698.         if (displayMode.Format == adapterFormat &&
  699.             displayMode.Width  == width &&
  700.             displayMode.Height == height)
  701.         {
  702.             TCHAR strRefreshRate[50];
  703.             if( displayMode.RefreshRate == 0 )
  704.                 lstrcpy( strRefreshRate, TEXT("Default Rate") );
  705.             else
  706.                 _sntprintf( strRefreshRate, 50, TEXT("%d Hz"), displayMode.RefreshRate );
  707.             strRefreshRate[49] = 0;
  708.             if( !ComboBoxContainsText( IDC_REFRESHRATE_COMBO, strRefreshRate ) )
  709.             {
  710.                 ComboBoxAdd( IDC_REFRESHRATE_COMBO, UlongToPtr( displayMode.RefreshRate ), strRefreshRate );
  711.                 if (m_d3dSettings.Fullscreen_DisplayMode.RefreshRate == displayMode.RefreshRate)
  712.                     ComboBoxSelect( IDC_REFRESHRATE_COMBO, UlongToPtr( displayMode.RefreshRate ) );
  713.             }
  714.         }
  715.     }
  716.     if (!ComboBoxSomethingSelected( IDC_REFRESHRATE_COMBO ) && 
  717.         ComboBoxCount( IDC_REFRESHRATE_COMBO ) > 0)
  718.     {
  719.         ComboBoxSelectIndex( IDC_REFRESHRATE_COMBO, 0 );
  720.     }
  721. }
  726. //-----------------------------------------------------------------------------
  727. // Name: RefreshRateChanged
  728. // Desc: Respond to a change of selected refresh rate.
  729. //-----------------------------------------------------------------------------
  730. void CD3DSettingsDialog::RefreshRateChanged( void )
  731. {
  732.     if( m_d3dSettings.IsWindowed )
  733.         return;
  735.     // Update settingsNew with new refresh rate
  736.     UINT refreshRate = PtrToUlong( ComboBoxSelected( IDC_REFRESHRATE_COMBO ) );
  737.     m_d3dSettings.Fullscreen_DisplayMode.RefreshRate = refreshRate;
  738. }
  743. //-----------------------------------------------------------------------------
  744. // Name: BackBufferFormatChanged
  745. // Desc: Respond to a change of selected back buffer format by rebuilding
  746. //       the depth/stencil format list, multisample type list, and vertex
  747. //       processing type list.
  748. //-----------------------------------------------------------------------------
  749. void CD3DSettingsDialog::BackBufferFormatChanged( void )
  750. {
  751.     D3DDeviceInfo* pDeviceInfo = (D3DDeviceInfo*)ComboBoxSelected( IDC_DEVICE_COMBO );
  752.     D3DFORMAT adapterFormat = (D3DFORMAT)PtrToUlong( ComboBoxSelected( IDC_ADAPTERFORMAT_COMBO ) );
  753.     D3DFORMAT backBufferFormat = (D3DFORMAT)PtrToUlong( ComboBoxSelected( IDC_BACKBUFFERFORMAT_COMBO ) );
  754.     if( pDeviceInfo == NULL )
  755.         return;
  757.     for( UINT idc = 0; idc < pDeviceInfo->pDeviceComboList->Count(); idc++ )
  758.     {
  759.         D3DDeviceCombo* pDeviceCombo = (D3DDeviceCombo*)pDeviceInfo->pDeviceComboList->GetPtr(idc);
  760.         if (pDeviceCombo->IsWindowed == m_d3dSettings.IsWindowed &&
  761.             pDeviceCombo->AdapterFormat == adapterFormat &&
  762.             pDeviceCombo->BackBufferFormat == backBufferFormat)
  763.         {
  764.             if( m_d3dSettings.IsWindowed )
  765.                 m_d3dSettings.pWindowed_DeviceCombo = pDeviceCombo;
  766.             else
  767.                 m_d3dSettings.pFullscreen_DeviceCombo = pDeviceCombo;
  769.             ComboBoxClear( IDC_DEPTHSTENCILBUFFERFORMAT_COMBO );
  770.             if( m_pEnumeration->AppUsesDepthBuffer )
  771.             {
  772.                 for( UINT ifmt = 0; ifmt < pDeviceCombo->pDepthStencilFormatList->Count(); ifmt++ )
  773.                 {
  774.                     D3DFORMAT fmt = *(D3DFORMAT*)pDeviceCombo->pDepthStencilFormatList->GetPtr(ifmt);
  775.                     ComboBoxAdd( IDC_DEPTHSTENCILBUFFERFORMAT_COMBO, (void*)fmt, 
  776.                         D3DUtil_D3DFormatToString(fmt) );
  777.                     if( fmt == m_d3dSettings.DepthStencilBufferFormat() )
  778.                         ComboBoxSelect( IDC_DEPTHSTENCILBUFFERFORMAT_COMBO, (void*)fmt );
  779.                 }
  780.                 if (!ComboBoxSomethingSelected( IDC_DEPTHSTENCILBUFFERFORMAT_COMBO ) && 
  781.                     ComboBoxCount( IDC_DEPTHSTENCILBUFFERFORMAT_COMBO ) > 0)
  782.                 {
  783.                     ComboBoxSelectIndex( IDC_DEPTHSTENCILBUFFERFORMAT_COMBO, 0 );
  784.                 }
  785.             }
  786.             else
  787.             {
  788.                 EnableWindow( GetDlgItem( m_hDlg, IDC_DEPTHSTENCILBUFFERFORMAT_COMBO ), false );
  789.                 ComboBoxAdd( IDC_DEPTHSTENCILBUFFERFORMAT_COMBO, NULL, TEXT("(not used)") );
  790.                 ComboBoxSelectIndex( IDC_DEPTHSTENCILBUFFERFORMAT_COMBO, 0 );
  791.             }
  793.             ComboBoxClear( IDC_VERTEXPROCESSING_COMBO );
  794.             for( UINT ivpt = 0; ivpt < pDeviceCombo->pVertexProcessingTypeList->Count(); ivpt++ )
  795.             {
  796.                 VertexProcessingType vpt = *(VertexProcessingType*)pDeviceCombo->pVertexProcessingTypeList->GetPtr(ivpt);
  797.                 ComboBoxAdd( IDC_VERTEXPROCESSING_COMBO, (void*)vpt, VertexProcessingTypeToString(vpt) );
  798.                 if( vpt == m_d3dSettings.GetVertexProcessingType() )
  799.                     ComboBoxSelect( IDC_VERTEXPROCESSING_COMBO, (void*)vpt );
  800.             }
  801.             if (!ComboBoxSomethingSelected( IDC_VERTEXPROCESSING_COMBO ) && 
  802.                 ComboBoxCount( IDC_VERTEXPROCESSING_COMBO ) > 0)
  803.             {
  804.                 ComboBoxSelectIndex( IDC_VERTEXPROCESSING_COMBO, 0 );
  805.             }
  807.             ComboBoxClear( IDC_PRESENTINTERVAL_COMBO );
  808.             for( UINT ipi = 0; ipi < pDeviceCombo->pPresentIntervalList->Count(); ipi++ )
  809.             {
  810.                 UINT pi = *(UINT*)pDeviceCombo->pPresentIntervalList->GetPtr(ipi);
  811.                 ComboBoxAdd( IDC_PRESENTINTERVAL_COMBO, UlongToPtr( pi ), PresentIntervalToString(pi) );
  812.                 if( pi == m_d3dSettings.PresentInterval() )
  813.                     ComboBoxSelect( IDC_PRESENTINTERVAL_COMBO, UlongToPtr( pi ) );
  814.             }
  815.             if (!ComboBoxSomethingSelected( IDC_PRESENTINTERVAL_COMBO ) && 
  816.                 ComboBoxCount( IDC_PRESENTINTERVAL_COMBO ) > 0)
  817.             {
  818.                 ComboBoxSelectIndex( IDC_PRESENTINTERVAL_COMBO, 0 );
  819.             }
  821.             break;
  822.         }
  823.     }
  824. }
  829. //-----------------------------------------------------------------------------
  830. // Name: DepthStencilBufferFormatChanged
  831. // Desc: Respond to a change of selected depth/stencil buffer format.
  832. //-----------------------------------------------------------------------------
  833. void CD3DSettingsDialog::DepthStencilBufferFormatChanged( void )
  834. {
  835.     D3DFORMAT fmt = (D3DFORMAT)PtrToUlong( ComboBoxSelected( IDC_DEPTHSTENCILBUFFERFORMAT_COMBO ) );
  836.     if( m_pEnumeration->AppUsesDepthBuffer )
  837.         m_d3dSettings.SetDepthStencilBufferFormat( fmt );
  839.     // Build multisample list
  840.     D3DDeviceCombo* pDeviceCombo = m_d3dSettings.PDeviceCombo();
  841.     ComboBoxClear( IDC_MULTISAMPLE_COMBO );
  842.     for( UINT ims = 0; ims < pDeviceCombo->pMultiSampleTypeList->Count(); ims++ )
  843.     {
  844.         D3DMULTISAMPLE_TYPE msType = *(D3DMULTISAMPLE_TYPE*)pDeviceCombo->pMultiSampleTypeList->GetPtr(ims);
  846.         // check for DS/MS conflicts
  847.         BOOL bConflictFound = FALSE;
  848.         for( UINT iConf = 0; iConf < pDeviceCombo->pDSMSConflictList->Count(); iConf++ )
  849.         {
  850.             D3DDSMSConflict* pDSMSConf = (D3DDSMSConflict*)pDeviceCombo->pDSMSConflictList->GetPtr(iConf);
  851.             if( pDSMSConf->DSFormat == fmt && pDSMSConf->MSType == msType )
  852.             {
  853.                 bConflictFound = TRUE;
  854.                 break;
  855.             }
  856.         }
  857.         if( !bConflictFound )
  858.         {
  859.             ComboBoxAdd( IDC_MULTISAMPLE_COMBO, (void*)msType, MultisampleTypeToString(msType) );
  860.             if( msType == m_d3dSettings.MultisampleType() )
  861.                 ComboBoxSelect( IDC_MULTISAMPLE_COMBO, (void*)msType );
  862.         }
  863.     }
  864.     if (!ComboBoxSomethingSelected( IDC_MULTISAMPLE_COMBO ) && 
  865.         ComboBoxCount( IDC_MULTISAMPLE_COMBO ) > 0)
  866.     {
  867.         ComboBoxSelectIndex( IDC_MULTISAMPLE_COMBO, 0 );
  868.     }
  869. }
  875. //-----------------------------------------------------------------------------
  876. // Name: MultisampleTypeChanged
  877. // Desc: Respond to a change of selected multisample type.
  878. //-----------------------------------------------------------------------------
  879. void CD3DSettingsDialog::MultisampleTypeChanged( void )
  880. {
  881.     D3DMULTISAMPLE_TYPE mst = (D3DMULTISAMPLE_TYPE)PtrToUlong( ComboBoxSelected( IDC_MULTISAMPLE_COMBO ) );
  882.     m_d3dSettings.SetMultisampleType( mst );
  884.     // Set up max quality for this mst
  885.     D3DDeviceCombo* pDeviceCombo = m_d3dSettings.PDeviceCombo();
  886.     DWORD maxQuality = 0;
  888.     for( UINT ims = 0; ims < pDeviceCombo->pMultiSampleTypeList->Count(); ims++ )
  889.     {
  890.         D3DMULTISAMPLE_TYPE msType = *(D3DMULTISAMPLE_TYPE*)pDeviceCombo->pMultiSampleTypeList->GetPtr(ims);
  891.         if( msType == mst )
  892.         {
  893.             maxQuality = *(DWORD*)pDeviceCombo->pMultiSampleQualityList->GetPtr(ims);
  894.             break;
  895.         }
  896.     }
  898.     ComboBoxClear( IDC_MULTISAMPLE_QUALITY_COMBO );
  899.     for( UINT msq = 0; msq < maxQuality; msq++ )
  900.     {
  901.         TCHAR str[100];
  902.         wsprintf( str, TEXT("%d"), msq );
  903.         ComboBoxAdd( IDC_MULTISAMPLE_QUALITY_COMBO, UlongToPtr( msq ), str );
  904.         if( msq == m_d3dSettings.MultisampleQuality() )
  905.             ComboBoxSelect( IDC_MULTISAMPLE_QUALITY_COMBO, UlongToPtr( msq ) );
  906.     }
  907.     if (!ComboBoxSomethingSelected( IDC_MULTISAMPLE_QUALITY_COMBO ) && 
  908.         ComboBoxCount( IDC_MULTISAMPLE_QUALITY_COMBO ) > 0)
  909.     {
  910.         ComboBoxSelectIndex( IDC_MULTISAMPLE_QUALITY_COMBO, 0 );
  911.     }
  912. }
  917. //-----------------------------------------------------------------------------
  918. // Name: MultisampleQualityChanged
  919. // Desc: Respond to a change of selected multisample quality.
  920. //-----------------------------------------------------------------------------
  921. void CD3DSettingsDialog::MultisampleQualityChanged( void )
  922. {
  923.     DWORD msq = (DWORD)PtrToUlong( ComboBoxSelected( IDC_MULTISAMPLE_QUALITY_COMBO ) );
  924.     m_d3dSettings.SetMultisampleQuality( msq );
  925. }
  930. //-----------------------------------------------------------------------------
  931. // Name: VertexProcessingChanged
  932. // Desc: Respond to a change of selected vertex processing type.
  933. //-----------------------------------------------------------------------------
  934. void CD3DSettingsDialog::VertexProcessingChanged( void )
  935. {
  936.     VertexProcessingType vpt = (VertexProcessingType)PtrToUlong( ComboBoxSelected( IDC_VERTEXPROCESSING_COMBO ) );
  937.     m_d3dSettings.SetVertexProcessingType( vpt );
  938. }
  943. //-----------------------------------------------------------------------------
  944. // Name: PresentIntervalChanged
  945. // Desc: Respond to a change of selected present interval.
  946. //-----------------------------------------------------------------------------
  947. void CD3DSettingsDialog::PresentIntervalChanged( void )
  948. {
  949.     UINT pi = PtrToUlong( ComboBoxSelected( IDC_PRESENTINTERVAL_COMBO ) );
  950.     m_d3dSettings.SetPresentInterval( pi );
  951. }
  956. //-----------------------------------------------------------------------------
  957. // Name: DeviceClipChanged
  958. // Desc: Respond to a change of selected present interval.
  959. //-----------------------------------------------------------------------------
  960. void CD3DSettingsDialog::DeviceClipChanged( void )
  961. {
  962.     HWND hWndCheckBox = GetDlgItem( m_hDlg, IDC_DEVICECLIP_CHECK );
  963.     if( hWndCheckBox )
  964.     {
  965.         bool bChecked = SendMessage( hWndCheckBox, BM_GETCHECK, 0, 0 ) == BST_CHECKED;
  966.         m_d3dSettings.SetDeviceClip( bChecked );
  967.     }
  968. }