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

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

游戏

开发平台：

Visual C++

d3denumeration.cpp：源码内容
  1. //-----------------------------------------------------------------------------
  2. // File: D3DEnumeration.cpp
  3. //
  4. // Desc: Enumerates D3D adapters, devices, modes, etc.
  5. //
  6. // Copyright (c) Microsoft Corporation. All rights reserved.
  7. //-----------------------------------------------------------------------------
  8. #include "dxstdafx.h"
  11. //-----------------------------------------------------------------------------
  12. // Name: ColorChannelBits
  13. // Desc: Returns the number of color channel bits in the specified D3DFORMAT
  14. //-----------------------------------------------------------------------------
  15. static UINT ColorChannelBits( D3DFORMAT fmt )
  16. {
  17.     switch( fmt )
  18.     {
  19.         case D3DFMT_R8G8B8:
  20.             return 8;
  21.         case D3DFMT_A8R8G8B8:
  22.             return 8;
  23.         case D3DFMT_X8R8G8B8:
  24.             return 8;
  25.         case D3DFMT_R5G6B5:
  26.             return 5;
  27.         case D3DFMT_X1R5G5B5:
  28.             return 5;
  29.         case D3DFMT_A1R5G5B5:
  30.             return 5;
  31.         case D3DFMT_A4R4G4B4:
  32.             return 4;
  33.         case D3DFMT_R3G3B2:
  34.             return 2;
  35.         case D3DFMT_A8R3G3B2:
  36.             return 2;
  37.         case D3DFMT_X4R4G4B4:
  38.             return 4;
  39.         case D3DFMT_A2B10G10R10:
  40.             return 10;
  41.         case D3DFMT_A2R10G10B10:
  42.             return 10;
  43.         default:
  44.             return 0;
  45.     }
  46. }
  51. //-----------------------------------------------------------------------------
  52. // Name: AlphaChannelBits
  53. // Desc: Returns the number of alpha channel bits in the specified D3DFORMAT
  54. //-----------------------------------------------------------------------------
  55. static UINT AlphaChannelBits( D3DFORMAT fmt )
  56. {
  57.     switch( fmt )
  58.     {
  59.         case D3DFMT_R8G8B8:
  60.             return 0;
  61.         case D3DFMT_A8R8G8B8:
  62.             return 8;
  63.         case D3DFMT_X8R8G8B8:
  64.             return 0;
  65.         case D3DFMT_R5G6B5:
  66.             return 0;
  67.         case D3DFMT_X1R5G5B5:
  68.             return 0;
  69.         case D3DFMT_A1R5G5B5:
  70.             return 1;
  71.         case D3DFMT_A4R4G4B4:
  72.             return 4;
  73.         case D3DFMT_R3G3B2:
  74.             return 0;
  75.         case D3DFMT_A8R3G3B2:
  76.             return 8;
  77.         case D3DFMT_X4R4G4B4:
  78.             return 0;
  79.         case D3DFMT_A2B10G10R10:
  80.             return 2;
  81.         case D3DFMT_A2R10G10B10:
  82.             return 2;
  83.         default:
  84.             return 0;
  85.     }
  86. }
  91. //-----------------------------------------------------------------------------
  92. // Name: DepthBits
  93. // Desc: Returns the number of depth bits in the specified D3DFORMAT
  94. //-----------------------------------------------------------------------------
  95. static UINT DepthBits( D3DFORMAT fmt )
  96. {
  97.     switch( fmt )
  98.     {
  99.         case D3DFMT_D16:
  100.             return 16;
  101.         case D3DFMT_D15S1:
  102.             return 15;
  103.         case D3DFMT_D24X8:
  104.             return 24;
  105.         case D3DFMT_D24S8:
  106.             return 24;
  107.         case D3DFMT_D24X4S4:
  108.             return 24;
  109.         case D3DFMT_D32:
  110.             return 32;
  111.         default:
  112.             return 0;
  113.     }
  114. }
  119. //-----------------------------------------------------------------------------
  120. // Name: StencilBits
  121. // Desc: Returns the number of stencil bits in the specified D3DFORMAT
  122. //-----------------------------------------------------------------------------
  123. static UINT StencilBits( D3DFORMAT fmt )
  124. {
  125.     switch( fmt )
  126.     {
  127.         case D3DFMT_D16:
  128.             return 0;
  129.         case D3DFMT_D15S1:
  130.             return 1;
  131.         case D3DFMT_D24X8:
  132.             return 0;
  133.         case D3DFMT_D24S8:
  134.             return 8;
  135.         case D3DFMT_D24X4S4:
  136.             return 4;
  137.         case D3DFMT_D32:
  138.             return 0;
  139.         default:
  140.             return 0;
  141.     }
  142. }
  147. //-----------------------------------------------------------------------------
  148. // Name: D3DAdapterInfo destructor
  149. // Desc: 
  150. //-----------------------------------------------------------------------------
  151. D3DAdapterInfo::~D3DAdapterInfo( void )
  152. {
  153.     if( pDisplayModeList != NULL )
  154.         delete pDisplayModeList;
  155.     if( pDeviceInfoList != NULL )
  156.     {
  157.         for( UINT idi = 0; idi < pDeviceInfoList->Count(); idi++ )
  158.             delete (D3DDeviceInfo*)pDeviceInfoList->GetPtr(idi);
  159.         delete pDeviceInfoList;
  160.     }
  161. }
  166. //-----------------------------------------------------------------------------
  167. // Name: D3DDeviceInfo destructor
  168. // Desc: 
  169. //-----------------------------------------------------------------------------
  170. D3DDeviceInfo::~D3DDeviceInfo( void )
  171. {
  172.     if( pDeviceComboList != NULL )
  173.     {
  174.         for( UINT idc = 0; idc < pDeviceComboList->Count(); idc++ )
  175.             delete (D3DDeviceCombo*)pDeviceComboList->GetPtr(idc);
  176.         delete pDeviceComboList;
  177.     }
  178. }
  183. //-----------------------------------------------------------------------------
  184. // Name: D3DDeviceCombo destructor
  185. // Desc: 
  186. //-----------------------------------------------------------------------------
  187. D3DDeviceCombo::~D3DDeviceCombo( void )
  188. {
  189.     if( pDepthStencilFormatList != NULL )
  190.         delete pDepthStencilFormatList;
  191.     if( pMultiSampleTypeList != NULL )
  192.         delete pMultiSampleTypeList;
  193.     if( pMultiSampleQualityList != NULL )
  194.         delete pMultiSampleQualityList;
  195.     if( pDSMSConflictList != NULL )
  196.         delete pDSMSConflictList;
  197.     if( pVertexProcessingTypeList != NULL )
  198.         delete pVertexProcessingTypeList;
  199.     if( pPresentIntervalList != NULL )
  200.         delete pPresentIntervalList;
  201. }
  205. //-----------------------------------------------------------------------------
  206. // Name: CD3DEnumeration constructor
  207. // Desc: 
  208. //-----------------------------------------------------------------------------
  209. CD3DEnumeration::CD3DEnumeration()
  210. {
  211.     m_pAdapterInfoList = NULL;
  212.     m_pAllowedAdapterFormatList = NULL;
  213.     AppMinFullscreenWidth = 640;
  214.     AppMinFullscreenHeight = 480;
  215.     AppMinColorChannelBits = 5;
  216.     AppMinAlphaChannelBits = 0;
  217.     AppMinDepthBits = 15;
  218.     AppMinStencilBits = 0;
  219.     AppUsesDepthBuffer = false;
  220.     AppUsesMixedVP = false;
  221.     AppRequiresWindowed = false;
  222.     AppRequiresFullscreen = false;
  223. }
  228. //-----------------------------------------------------------------------------
  229. // Name: CD3DEnumeration destructor
  230. // Desc: 
  231. //-----------------------------------------------------------------------------
  232. CD3DEnumeration::~CD3DEnumeration()
  233. {
  234.     if( m_pAdapterInfoList != NULL )
  235.     {
  236.         for( UINT iai = 0; iai < m_pAdapterInfoList->Count(); iai++ )
  237.             delete (D3DAdapterInfo*)m_pAdapterInfoList->GetPtr(iai);
  238.         delete m_pAdapterInfoList;
  239.     }
  240.     SAFE_DELETE( m_pAllowedAdapterFormatList );
  241. }
  246. //-----------------------------------------------------------------------------
  247. // Name: SortModesCallback
  248. // Desc: Used to sort D3DDISPLAYMODEs
  249. //-----------------------------------------------------------------------------
  250. static int __cdecl SortModesCallback( const void* arg1, const void* arg2 )
  251. {
  252.     D3DDISPLAYMODE* pdm1 = (D3DDISPLAYMODE*)arg1;
  253.     D3DDISPLAYMODE* pdm2 = (D3DDISPLAYMODE*)arg2;
  255.     if (pdm1->Width > pdm2->Width)
  256.         return 1;
  257.     if (pdm1->Width < pdm2->Width)
  258.         return -1;
  259.     if (pdm1->Height > pdm2->Height)
  260.         return 1;
  261.     if (pdm1->Height < pdm2->Height)
  262.         return -1;
  263.     if (pdm1->Format > pdm2->Format)
  264.         return 1;
  265.     if (pdm1->Format < pdm2->Format)
  266.         return -1;
  267.     if (pdm1->RefreshRate > pdm2->RefreshRate)
  268.         return 1;
  269.     if (pdm1->RefreshRate < pdm2->RefreshRate)
  270.         return -1;
  271.     return 0;
  272. }
  277. //-----------------------------------------------------------------------------
  278. // Name: Enumerate
  279. // Desc: Enumerates available D3D adapters, devices, modes, etc.
  280. //-----------------------------------------------------------------------------
  281. HRESULT CD3DEnumeration::Enumerate()
  282. {
  283.     HRESULT hr;
  284.     CArrayList adapterFormatList( AL_VALUE, sizeof(D3DFORMAT) );
  286.     if( m_pD3D == NULL )
  287.         return E_FAIL;
  289.     m_pAdapterInfoList = new CArrayList( AL_REFERENCE );
  290.     if( m_pAdapterInfoList == NULL )
  291.         return E_OUTOFMEMORY;
  293.     m_pAllowedAdapterFormatList = new CArrayList( AL_VALUE, sizeof(D3DFORMAT) );
  294.     if( m_pAllowedAdapterFormatList == NULL )
  295.         return E_OUTOFMEMORY;
  296.     D3DFORMAT fmt;
  297.     if( FAILED( hr = m_pAllowedAdapterFormatList->Add( &( fmt = D3DFMT_X8R8G8B8 ) ) ) )
  298.         return hr;
  299.     if( FAILED( hr = m_pAllowedAdapterFormatList->Add( &( fmt = D3DFMT_X1R5G5B5 ) ) ) )
  300.         return hr;
  301.     if( FAILED( hr = m_pAllowedAdapterFormatList->Add( &( fmt = D3DFMT_R5G6B5 ) ) ) )
  302.         return hr;
  303.     if( FAILED( hr = m_pAllowedAdapterFormatList->Add( &( fmt = D3DFMT_A2R10G10B10 ) ) ) )
  304.         return hr;
  306.     D3DAdapterInfo* pAdapterInfo = NULL;
  307.     UINT numAdapters = m_pD3D->GetAdapterCount();
  309.     for (UINT adapterOrdinal = 0; adapterOrdinal < numAdapters; adapterOrdinal++)
  310.     {
  311.         pAdapterInfo = new D3DAdapterInfo;
  312.         if( pAdapterInfo == NULL )
  313.             return E_OUTOFMEMORY;
  314.         pAdapterInfo->pDisplayModeList = new CArrayList( AL_VALUE, sizeof(D3DDISPLAYMODE)); 
  315.         pAdapterInfo->pDeviceInfoList = new CArrayList( AL_REFERENCE );
  316.         if( pAdapterInfo->pDisplayModeList == NULL ||
  317.             pAdapterInfo->pDeviceInfoList == NULL )
  318.         {
  319.             delete pAdapterInfo;
  320.             return E_OUTOFMEMORY;
  321.         }
  322.         pAdapterInfo->AdapterOrdinal = adapterOrdinal;
  323.         m_pD3D->GetAdapterIdentifier(adapterOrdinal, 0, &pAdapterInfo->AdapterIdentifier);
  325.         // Get list of all display modes on this adapter.  
  326.         // Also build a temporary list of all display adapter formats.
  327.         adapterFormatList.Clear();
  328.         for( UINT iaaf = 0; iaaf < m_pAllowedAdapterFormatList->Count(); iaaf++ )
  329.         {
  330.             D3DFORMAT allowedAdapterFormat = *(D3DFORMAT*)m_pAllowedAdapterFormatList->GetPtr( iaaf );
  331.             UINT numAdapterModes = m_pD3D->GetAdapterModeCount( adapterOrdinal, allowedAdapterFormat );
  332.             for (UINT mode = 0; mode < numAdapterModes; mode++)
  333.             {
  334.                 D3DDISPLAYMODE displayMode;
  335.                 m_pD3D->EnumAdapterModes( adapterOrdinal, allowedAdapterFormat, mode, &displayMode );
  336.                 if( displayMode.Width < AppMinFullscreenWidth ||
  337.                     displayMode.Height < AppMinFullscreenHeight ||
  338.                     ColorChannelBits(displayMode.Format) < AppMinColorChannelBits )
  339.                 {
  340.                     continue;
  341.                 }
  342.                 pAdapterInfo->pDisplayModeList->Add(&displayMode);
  343.                 if( !adapterFormatList.Contains( &displayMode.Format ) )
  344.                     adapterFormatList.Add( &displayMode.Format );
  345.             }
  346.         }
  348.         // Sort displaymode list
  349.         qsort( pAdapterInfo->pDisplayModeList->GetPtr(0), 
  350.             pAdapterInfo->pDisplayModeList->Count(), sizeof( D3DDISPLAYMODE ),
  351.             SortModesCallback );
  353.         // Get info for each device on this adapter
  354.         if( FAILED( hr = EnumerateDevices( pAdapterInfo, &adapterFormatList ) ) )
  355.         {
  356.             delete pAdapterInfo;
  357.             return hr;
  358.         }
  360.         // If at least one device on this adapter is available and compatible
  361.         // with the app, add the adapterInfo to the list
  362.         if (pAdapterInfo->pDeviceInfoList->Count() == 0)
  363.             delete pAdapterInfo;
  364.         else
  365.             m_pAdapterInfoList->Add(pAdapterInfo);
  366.     }
  367.     return S_OK;
  368. }
  373. //-----------------------------------------------------------------------------
  374. // Name: EnumerateDevices
  375. // Desc: Enumerates D3D devices for a particular adapter.
  376. //-----------------------------------------------------------------------------
  377. HRESULT CD3DEnumeration::EnumerateDevices( D3DAdapterInfo* pAdapterInfo, 
  378.                                            CArrayList* pAdapterFormatList )
  379. {
  380.     const D3DDEVTYPE devTypeArray[] = { D3DDEVTYPE_HAL, D3DDEVTYPE_SW, D3DDEVTYPE_REF };
  381.     const UINT devTypeArrayCount = sizeof(devTypeArray) / sizeof(devTypeArray[0]);
  382.     HRESULT hr;
  384.     D3DDeviceInfo* pDeviceInfo = NULL;
  385.     for( UINT idt = 0; idt < devTypeArrayCount; idt++ )
  386.     {
  387.         pDeviceInfo = new D3DDeviceInfo;
  388.         if( pDeviceInfo == NULL )
  389.             return E_OUTOFMEMORY;
  390.         pDeviceInfo->pDeviceComboList = new CArrayList( AL_REFERENCE ); 
  391.         if( pDeviceInfo->pDeviceComboList == NULL )
  392.         {
  393.             delete pDeviceInfo;
  394.             return E_OUTOFMEMORY;
  395.         }
  396.         pDeviceInfo->AdapterOrdinal = pAdapterInfo->AdapterOrdinal;
  397.         pDeviceInfo->DevType = devTypeArray[idt];
  398.         if( FAILED( m_pD3D->GetDeviceCaps( pAdapterInfo->AdapterOrdinal, 
  399.             pDeviceInfo->DevType, &pDeviceInfo->Caps ) ) )
  400.         {
  401.             delete pDeviceInfo;
  402.             continue;
  403.         }
  405.         // Get info for each devicecombo on this device
  406.         if( FAILED( hr = EnumerateDeviceCombos(pDeviceInfo, pAdapterFormatList) ) )
  407.         {
  408.             delete pDeviceInfo;
  409.             return hr;
  410.         }
  412.         // If at least one devicecombo for this device is found, 
  413.         // add the deviceInfo to the list
  414.         if (pDeviceInfo->pDeviceComboList->Count() == 0)
  415.         {
  416.             delete pDeviceInfo;
  417.             continue;
  418.         }
  419.         pAdapterInfo->pDeviceInfoList->Add(pDeviceInfo);
  420.     }
  421.     return S_OK;
  422. }
  427. //-----------------------------------------------------------------------------
  428. // Name: EnumerateDeviceCombos
  429. // Desc: Enumerates DeviceCombos for a particular device.
  430. //-----------------------------------------------------------------------------
  431. HRESULT CD3DEnumeration::EnumerateDeviceCombos( D3DDeviceInfo* pDeviceInfo, 
  432.                                                CArrayList* pAdapterFormatList )
  433. {
  434.     const D3DFORMAT backBufferFormatArray[] = 
  435.         {   D3DFMT_A8R8G8B8, D3DFMT_X8R8G8B8, D3DFMT_A2R10G10B10, 
  436.             D3DFMT_R5G6B5, D3DFMT_A1R5G5B5, D3DFMT_X1R5G5B5 };
  437.     const UINT backBufferFormatArrayCount = sizeof(backBufferFormatArray) / sizeof(backBufferFormatArray[0]);
  438.     bool isWindowedArray[] = { false, true };
  440.     // See which adapter formats are supported by this device
  441.     D3DFORMAT adapterFormat;
  442.     for( UINT iaf = 0; iaf < pAdapterFormatList->Count(); iaf++ )
  443.     {
  444.         adapterFormat = *(D3DFORMAT*)pAdapterFormatList->GetPtr(iaf);
  445.         D3DFORMAT backBufferFormat;
  446.         for( UINT ibbf = 0; ibbf < backBufferFormatArrayCount; ibbf++ )
  447.         {
  448.             backBufferFormat = backBufferFormatArray[ibbf];
  449.             if (AlphaChannelBits(backBufferFormat) < AppMinAlphaChannelBits)
  450.                 continue;
  451.             bool isWindowed;
  452.             for( UINT iiw = 0; iiw < 2; iiw++)
  453.             {
  454.                 isWindowed = isWindowedArray[iiw];
  455.                 if (!isWindowed && AppRequiresWindowed)
  456.                     continue;
  457.                 if (isWindowed && AppRequiresFullscreen)
  458.                     continue;
  459.                 if (FAILED(m_pD3D->CheckDeviceType(pDeviceInfo->AdapterOrdinal, pDeviceInfo->DevType, 
  460.                     adapterFormat, backBufferFormat, isWindowed)))
  461.                 {
  462.                     continue;
  463.                 }
  464.                 // At this point, we have an adapter/device/adapterformat/backbufferformat/iswindowed
  465.                 // DeviceCombo that is supported by the system.  We still need to confirm that it's 
  466.                 // compatible with the app, and find one or more suitable depth/stencil buffer format,
  467.                 // multisample type, vertex processing type, and present interval.
  468.                 D3DDeviceCombo* pDeviceCombo = NULL;
  469.                 pDeviceCombo = new D3DDeviceCombo;
  470.                 if( pDeviceCombo == NULL )
  471.                     return E_OUTOFMEMORY;
  472.                 pDeviceCombo->pDepthStencilFormatList = new CArrayList( AL_VALUE, sizeof( D3DFORMAT ) );
  473.                 pDeviceCombo->pMultiSampleTypeList = new CArrayList( AL_VALUE, sizeof( D3DMULTISAMPLE_TYPE ) );
  474.                 pDeviceCombo->pMultiSampleQualityList = new CArrayList( AL_VALUE, sizeof( DWORD ) );
  475.                 pDeviceCombo->pDSMSConflictList = new CArrayList( AL_VALUE, sizeof( D3DDSMSConflict ) );
  476.                 pDeviceCombo->pVertexProcessingTypeList = new CArrayList( AL_VALUE, sizeof( VertexProcessingType ) );
  477.                 pDeviceCombo->pPresentIntervalList = new CArrayList( AL_VALUE, sizeof( UINT ) );
  478.                 if( pDeviceCombo->pDepthStencilFormatList == NULL ||
  479.                     pDeviceCombo->pMultiSampleTypeList == NULL || 
  480.                     pDeviceCombo->pMultiSampleQualityList == NULL || 
  481.                     pDeviceCombo->pDSMSConflictList == NULL || 
  482.                     pDeviceCombo->pVertexProcessingTypeList == NULL ||
  483.                     pDeviceCombo->pPresentIntervalList == NULL )
  484.                 {
  485.                     delete pDeviceCombo;
  486.                     return E_OUTOFMEMORY;
  487.                 }
  488.                 pDeviceCombo->AdapterOrdinal = pDeviceInfo->AdapterOrdinal;
  489.                 pDeviceCombo->DevType = pDeviceInfo->DevType;
  490.                 pDeviceCombo->AdapterFormat = adapterFormat;
  491.                 pDeviceCombo->BackBufferFormat = backBufferFormat;
  492.                 pDeviceCombo->IsWindowed = isWindowed;
  493.                 if (AppUsesDepthBuffer)
  494.                 {
  495.                     BuildDepthStencilFormatList(pDeviceCombo);
  496.                     if (pDeviceCombo->pDepthStencilFormatList->Count() == 0)
  497.                     {
  498.                         delete pDeviceCombo;
  499.                         continue;
  500.                     }
  501.                 }
  502.                 BuildMultiSampleTypeList(pDeviceCombo);
  503.                 if (pDeviceCombo->pMultiSampleTypeList->Count() == 0)
  504.                 {
  505.                     delete pDeviceCombo;
  506.                     continue;
  507.                 }
  508.                 BuildDSMSConflictList(pDeviceCombo);
  509.                 BuildVertexProcessingTypeList(pDeviceInfo, pDeviceCombo);
  510.                 if (pDeviceCombo->pVertexProcessingTypeList->Count() == 0)
  511.                 {
  512.                     delete pDeviceCombo;
  513.                     continue;
  514.                 }
  515.                 BuildPresentIntervalList(pDeviceInfo, pDeviceCombo);
  517.                 pDeviceInfo->pDeviceComboList->Add(pDeviceCombo);
  518.             }
  519.         }
  520.     }
  522.     return S_OK;
  523. }
  528. //-----------------------------------------------------------------------------
  529. // Name: BuildDepthStencilFormatList
  530. // Desc: Adds all depth/stencil formats that are compatible with the device 
  531. //       and app to the given D3DDeviceCombo.
  532. //-----------------------------------------------------------------------------
  533. void CD3DEnumeration::BuildDepthStencilFormatList( D3DDeviceCombo* pDeviceCombo )
  534. {
  535.     const D3DFORMAT depthStencilFormatArray[] = 
  536.     {
  537.         D3DFMT_D16,
  538.         D3DFMT_D15S1,
  539.         D3DFMT_D24X8,
  540.         D3DFMT_D24S8,
  541.         D3DFMT_D24X4S4,
  542.         D3DFMT_D32,
  543.     };
  544.     const UINT depthStencilFormatArrayCount = sizeof(depthStencilFormatArray) / 
  545.                                               sizeof(depthStencilFormatArray[0]);
  547.     D3DFORMAT depthStencilFmt;
  548.     for( UINT idsf = 0; idsf < depthStencilFormatArrayCount; idsf++ )
  549.     {
  550.         depthStencilFmt = depthStencilFormatArray[idsf];
  551.         if (DepthBits(depthStencilFmt) < AppMinDepthBits)
  552.             continue;
  553.         if (StencilBits(depthStencilFmt) < AppMinStencilBits)
  554.             continue;
  555.         if (SUCCEEDED(m_pD3D->CheckDeviceFormat(pDeviceCombo->AdapterOrdinal, 
  556.             pDeviceCombo->DevType, pDeviceCombo->AdapterFormat, 
  557.             D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, depthStencilFmt)))
  558.         {
  559.             if (SUCCEEDED(m_pD3D->CheckDepthStencilMatch(pDeviceCombo->AdapterOrdinal, 
  560.                 pDeviceCombo->DevType, pDeviceCombo->AdapterFormat, 
  561.                 pDeviceCombo->BackBufferFormat, depthStencilFmt)))
  562.             {
  563.                 pDeviceCombo->pDepthStencilFormatList->Add(&depthStencilFmt);
  564.             }
  565.         }
  566.     }
  567. }
  572. //-----------------------------------------------------------------------------
  573. // Name: BuildMultiSampleTypeList
  574. // Desc: Adds all multisample types that are compatible with the device and app to
  575. //       the given D3DDeviceCombo.
  576. //-----------------------------------------------------------------------------
  577. void CD3DEnumeration::BuildMultiSampleTypeList( D3DDeviceCombo* pDeviceCombo )
  578. {
  579.     const D3DMULTISAMPLE_TYPE msTypeArray[] = { 
  580.         D3DMULTISAMPLE_NONE,
  581.         D3DMULTISAMPLE_NONMASKABLE,
  582.         D3DMULTISAMPLE_2_SAMPLES,
  583.         D3DMULTISAMPLE_3_SAMPLES,
  584.         D3DMULTISAMPLE_4_SAMPLES,
  585.         D3DMULTISAMPLE_5_SAMPLES,
  586.         D3DMULTISAMPLE_6_SAMPLES,
  587.         D3DMULTISAMPLE_7_SAMPLES,
  588.         D3DMULTISAMPLE_8_SAMPLES,
  589.         D3DMULTISAMPLE_9_SAMPLES,
  590.         D3DMULTISAMPLE_10_SAMPLES,
  591.         D3DMULTISAMPLE_11_SAMPLES,
  592.         D3DMULTISAMPLE_12_SAMPLES,
  593.         D3DMULTISAMPLE_13_SAMPLES,
  594.         D3DMULTISAMPLE_14_SAMPLES,
  595.         D3DMULTISAMPLE_15_SAMPLES,
  596.         D3DMULTISAMPLE_16_SAMPLES,
  597.     };
  598.     const UINT msTypeArrayCount = sizeof(msTypeArray) / sizeof(msTypeArray[0]);
  600.     D3DMULTISAMPLE_TYPE msType;
  601.     DWORD msQuality;
  602.     for( UINT imst = 0; imst < msTypeArrayCount; imst++ )
  603.     {
  604.         msType = msTypeArray[imst];
  605.         if (SUCCEEDED(m_pD3D->CheckDeviceMultiSampleType(pDeviceCombo->AdapterOrdinal, pDeviceCombo->DevType, 
  606.             pDeviceCombo->BackBufferFormat, pDeviceCombo->IsWindowed, msType, &msQuality)))
  607.         {
  608.             pDeviceCombo->pMultiSampleTypeList->Add(&msType);
  609.             pDeviceCombo->pMultiSampleQualityList->Add( &msQuality );
  610.         }
  611.     }
  612. }
  617. //-----------------------------------------------------------------------------
  618. // Name: BuildDSMSConflictList
  619. // Desc: Find any conflicts between the available depth/stencil formats and
  620. //       multisample types.
  621. //-----------------------------------------------------------------------------
  622. void CD3DEnumeration::BuildDSMSConflictList( D3DDeviceCombo* pDeviceCombo )
  623. {
  624.     D3DDSMSConflict DSMSConflict;
  626.     for( UINT ids = 0; ids < pDeviceCombo->pDepthStencilFormatList->Count(); ids++ )
  627.     {
  628.         D3DFORMAT dsFmt = *(D3DFORMAT*)pDeviceCombo->pDepthStencilFormatList->GetPtr(ids);
  629.         for( UINT ims = 0; ims < pDeviceCombo->pMultiSampleTypeList->Count(); ims++ )
  630.         {
  631.             D3DMULTISAMPLE_TYPE msType = *(D3DMULTISAMPLE_TYPE*)pDeviceCombo->pMultiSampleTypeList->GetPtr(ims);
  632.             if( FAILED( m_pD3D->CheckDeviceMultiSampleType( pDeviceCombo->AdapterOrdinal, pDeviceCombo->DevType,
  633.                 dsFmt, pDeviceCombo->IsWindowed, msType, NULL ) ) )
  634.             {
  635.                 DSMSConflict.DSFormat = dsFmt;
  636.                 DSMSConflict.MSType = msType;
  637.                 pDeviceCombo->pDSMSConflictList->Add( &DSMSConflict );
  638.             }
  639.         }
  640.     }
  641. }
  646. //-----------------------------------------------------------------------------
  647. // Name: BuildVertexProcessingTypeList
  648. // Desc: Adds all vertex processing types that are compatible with the device 
  649. //       and app to the given D3DDeviceCombo.
  650. //-----------------------------------------------------------------------------
  651. void CD3DEnumeration::BuildVertexProcessingTypeList( D3DDeviceInfo* pDeviceInfo, 
  652.                                                      D3DDeviceCombo* pDeviceCombo )
  653. {
  654.     VertexProcessingType vpt;
  655.     if ((pDeviceInfo->Caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT) != 0)
  656.     {
  657.         if ((pDeviceInfo->Caps.DevCaps & D3DDEVCAPS_PUREDEVICE) != 0)
  658.         {
  659.             if (ConfirmDeviceCallback == NULL ||
  660.                 ConfirmDeviceCallback(&pDeviceInfo->Caps, PURE_HARDWARE_VP, 
  661.                 pDeviceCombo->AdapterFormat, pDeviceCombo->BackBufferFormat))
  662.             {
  663.                 vpt = PURE_HARDWARE_VP;
  664.                 pDeviceCombo->pVertexProcessingTypeList->Add(&vpt);
  665.             }
  666.         }
  667.         if (ConfirmDeviceCallback == NULL ||
  668.             ConfirmDeviceCallback(&pDeviceInfo->Caps, HARDWARE_VP, 
  669.             pDeviceCombo->AdapterFormat, pDeviceCombo->BackBufferFormat))
  670.         {
  671.             vpt = HARDWARE_VP;
  672.             pDeviceCombo->pVertexProcessingTypeList->Add(&vpt);
  673.         }
  674.         if (AppUsesMixedVP && (ConfirmDeviceCallback == NULL ||
  675.             ConfirmDeviceCallback(&pDeviceInfo->Caps, MIXED_VP, 
  676.             pDeviceCombo->AdapterFormat, pDeviceCombo->BackBufferFormat)))
  677.         {
  678.             vpt = MIXED_VP;
  679.             pDeviceCombo->pVertexProcessingTypeList->Add(&vpt);
  680.         }
  681.     }
  682.     if (ConfirmDeviceCallback == NULL ||
  683.         ConfirmDeviceCallback(&pDeviceInfo->Caps, SOFTWARE_VP, 
  684.         pDeviceCombo->AdapterFormat, pDeviceCombo->BackBufferFormat))
  685.     {
  686.         vpt = SOFTWARE_VP;
  687.         pDeviceCombo->pVertexProcessingTypeList->Add(&vpt);
  688.     }
  689. }
  694. //-----------------------------------------------------------------------------
  695. // Name: BuildPresentIntervalList
  696. // Desc: Adds all present intervals that are compatible with the device and app 
  697. //       to the given D3DDeviceCombo.
  698. //-----------------------------------------------------------------------------
  699. void CD3DEnumeration::BuildPresentIntervalList( D3DDeviceInfo* pDeviceInfo, 
  700.                                                 D3DDeviceCombo* pDeviceCombo )
  701. {
  702.     const UINT piArray[] = { 
  703.         D3DPRESENT_INTERVAL_IMMEDIATE,
  704.         D3DPRESENT_INTERVAL_DEFAULT,
  705.         D3DPRESENT_INTERVAL_ONE,
  706.         D3DPRESENT_INTERVAL_TWO,
  707.         D3DPRESENT_INTERVAL_THREE,
  708.         D3DPRESENT_INTERVAL_FOUR,
  709.     };
  710.     const UINT piArrayCount = sizeof(piArray) / sizeof(piArray[0]);
  712.     UINT pi;
  713.     for( UINT ipi = 0; ipi < piArrayCount; ipi++ )
  714.     {
  715.         pi = piArray[ipi];
  716.         if( pDeviceCombo->IsWindowed )
  717.         {
  718.             if( pi == D3DPRESENT_INTERVAL_TWO ||
  719.                 pi == D3DPRESENT_INTERVAL_THREE ||
  720.                 pi == D3DPRESENT_INTERVAL_FOUR )
  721.             {
  722.                 // These intervals are not supported in windowed mode.
  723.                 continue;
  724.             }
  725.         }
  726.         // Note that D3DPRESENT_INTERVAL_DEFAULT is zero, so you
  727.         // can't do a caps check for it -- it is always available.
  728.         if( pi == D3DPRESENT_INTERVAL_DEFAULT ||
  729.             (pDeviceInfo->Caps.PresentationIntervals & pi) )
  730.         {
  731.             pDeviceCombo->pPresentIntervalList->Add( &pi );
  732.         }
  733.     }
  734. }