Restructuring starts. Got some initial CMake problems sorted. Need to extend.

1 files changed, 0 insertions, 1177 deletions

diff --git a/sample/d3d11/common/DXUTDevice9.cpp b/sample/d3d11/common/DXUTDevice9.cpp
deleted file mode 100644
index 35ae3ec..0000000
--- a/sample/d3d11/common/DXUTDevice9.cpp
+++ /dev/null
@@ -1,1177 +0,0 @@
-//--------------------------------------------------------------------------------------
-// File: DXUTDevice9.cpp
-//
-// Enumerates D3D adapters, devices, modes, etc.
-//
-// Copyright (c) Microsoft Corporation. All rights reserved.
-//--------------------------------------------------------------------------------------
-#include "DXUT.h"
-#undef min // use __min instead
-#undef max // use __max instead
-
-//--------------------------------------------------------------------------------------
-// Forward declarations
-//--------------------------------------------------------------------------------------
-extern void DXUTGetCallbackD3D9DeviceAcceptable( LPDXUTCALLBACKISD3D9DEVICEACCEPTABLE* ppCallbackIsDeviceAcceptable, void** ppUserContext );
-
-
-
-
-static int __cdecl SortModesCallback( const void* arg1, const void* arg2 );
-
-
-CD3D9Enumeration*   g_pDXUTD3D9Enumeration = NULL;
-
-HRESULT WINAPI DXUTCreateD3D9Enumeration()
-{
-    if( g_pDXUTD3D9Enumeration == NULL )
-    {
-        g_pDXUTD3D9Enumeration = new CD3D9Enumeration();
-        if( NULL == g_pDXUTD3D9Enumeration )
-            return E_OUTOFMEMORY;
-    }
-    return S_OK;
-}
-
-void WINAPI DXUTDestroyD3D9Enumeration()
-{
-    SAFE_DELETE( g_pDXUTD3D9Enumeration );
-}
-
-class DXUTMemoryHelperD3D9Enum
-{
-public:
-DXUTMemoryHelperD3D9Enum()
-{
-    DXUTCreateD3D9Enumeration();
-}
-~DXUTMemoryHelperD3D9Enum()
-{
-    DXUTDestroyD3D9Enumeration();
-}
-};
-
-//--------------------------------------------------------------------------------------
-CD3D9Enumeration* WINAPI DXUTGetD3D9Enumeration( bool bForceEnumerate )
-{
-    // Using an static class with accessor function to allow control of the construction order
-    static DXUTMemoryHelperD3D9Enum d3d9enumMemory;
-
-    if( g_pDXUTD3D9Enumeration && ( !g_pDXUTD3D9Enumeration->HasEnumerated() || bForceEnumerate ) )
-    {
-        LPDXUTCALLBACKISD3D9DEVICEACCEPTABLE pCallbackIsDeviceAcceptable;
-        void* pUserContext;
-        DXUTGetCallbackD3D9DeviceAcceptable( &pCallbackIsDeviceAcceptable, &pUserContext );
-        g_pDXUTD3D9Enumeration->Enumerate( pCallbackIsDeviceAcceptable, pUserContext );
-    }
-
-    return g_pDXUTD3D9Enumeration;
-}
-
-
-//--------------------------------------------------------------------------------------
-CD3D9Enumeration::CD3D9Enumeration()
-{
-    m_bHasEnumerated = false;
-    m_pD3D = NULL;
-    m_IsD3D9DeviceAcceptableFunc = NULL;
-    m_pIsD3D9DeviceAcceptableFuncUserContext = NULL;
-    m_bRequirePostPixelShaderBlending = true;
-
-    m_nMinWidth = 640;
-    m_nMinHeight = 480;
-    m_nMaxWidth = UINT_MAX;
-    m_nMaxHeight = UINT_MAX;
-
-    m_nRefreshMin = 0;
-    m_nRefreshMax = UINT_MAX;
-
-    m_nMultisampleQualityMax = 0xFFFF;
-
-    ResetPossibleDepthStencilFormats();
-    ResetPossibleMultisampleTypeList();
-    ResetPossiblePresentIntervalList();
-    SetPossibleVertexProcessingList( true, true, true, false );
-}
-
-
-//--------------------------------------------------------------------------------------
-CD3D9Enumeration::~CD3D9Enumeration()
-{
-    ClearAdapterInfoList();
-}
-
-
-
-//--------------------------------------------------------------------------------------
-// Enumerate for each adapter all of the supported display modes, 
-// device types, adapter formats, back buffer formats, window/full screen support, 
-// depth stencil formats, multisampling types/qualities, and presentations intervals.
-//
-// For each combination of device type (HAL/REF), adapter format, back buffer format, and
-// IsWindowed it will call the app's ConfirmDevice callback.  This allows the app
-// to reject or allow that combination based on its caps/etc.  It also allows the 
-// app to change the BehaviorFlags.  The BehaviorFlags defaults non-pure HWVP 
-// if supported otherwise it will default to SWVP, however the app can change this 
-// through the ConfirmDevice callback.
-//--------------------------------------------------------------------------------------
-HRESULT CD3D9Enumeration::Enumerate( LPDXUTCALLBACKISD3D9DEVICEACCEPTABLE IsD3D9DeviceAcceptableFunc,
-                                     void* pIsD3D9DeviceAcceptableFuncUserContext )
-{
-    CDXUTPerfEventGenerator eventGenerator( DXUT_PERFEVENTCOLOR, L"DXUT D3D9 Enumeration" );
-    IDirect3D9* pD3D = DXUTGetD3D9Object();
-    if( pD3D == NULL )
-    {
-        pD3D = DXUTGetD3D9Object();
-        if( pD3D == NULL )
-            return DXUTERR_NODIRECT3D;
-    }
-
-    m_bHasEnumerated = true;
-    m_pD3D = pD3D;
-    m_IsD3D9DeviceAcceptableFunc = IsD3D9DeviceAcceptableFunc;
-    m_pIsD3D9DeviceAcceptableFuncUserContext = pIsD3D9DeviceAcceptableFuncUserContext;
-
-    HRESULT hr;
-    ClearAdapterInfoList();
-    CGrowableArray <D3DFORMAT> adapterFormatList;
-
-    const D3DFORMAT allowedAdapterFormatArray[] =
-    {
-        D3DFMT_X8R8G8B8,
-        D3DFMT_X1R5G5B5,
-        D3DFMT_R5G6B5,
-        D3DFMT_A2R10G10B10
-    };
-    const UINT allowedAdapterFormatArrayCount = sizeof( allowedAdapterFormatArray ) / sizeof
-        ( allowedAdapterFormatArray[0] );
-
-    UINT numAdapters = pD3D->GetAdapterCount();
-    for( UINT adapterOrdinal = 0; adapterOrdinal < numAdapters; adapterOrdinal++ )
-    {
-        CD3D9EnumAdapterInfo* pAdapterInfo = new CD3D9EnumAdapterInfo;
-        if( pAdapterInfo == NULL )
-            return E_OUTOFMEMORY;
-
-        pAdapterInfo->AdapterOrdinal = adapterOrdinal;
-        pD3D->GetAdapterIdentifier( adapterOrdinal, 0, &pAdapterInfo->AdapterIdentifier );
-
-        // Get list of all display modes on this adapter.  
-        // Also build a temporary list of all display adapter formats.
-        adapterFormatList.RemoveAll();
-
-        for( UINT iFormatList = 0; iFormatList < allowedAdapterFormatArrayCount; iFormatList++ )
-        {
-            D3DFORMAT allowedAdapterFormat = allowedAdapterFormatArray[iFormatList];
-            UINT numAdapterModes = pD3D->GetAdapterModeCount( adapterOrdinal, allowedAdapterFormat );
-            for( UINT mode = 0; mode < numAdapterModes; mode++ )
-            {
-                D3DDISPLAYMODE displayMode;
-                pD3D->EnumAdapterModes( adapterOrdinal, allowedAdapterFormat, mode, &displayMode );
-
-                if( displayMode.Width < m_nMinWidth ||
-                    displayMode.Height < m_nMinHeight ||
-                    displayMode.Width > m_nMaxWidth ||
-                    displayMode.Height > m_nMaxHeight ||
-                    displayMode.RefreshRate < m_nRefreshMin ||
-                    displayMode.RefreshRate > m_nRefreshMax )
-                {
-                    continue;
-                }
-
-                pAdapterInfo->displayModeList.Add( displayMode );
-
-                if( !adapterFormatList.Contains( displayMode.Format ) )
-                    adapterFormatList.Add( displayMode.Format );
-            }
-
-        }
-
-        D3DDISPLAYMODE displayMode;
-        pD3D->GetAdapterDisplayMode( adapterOrdinal, &displayMode );
-        if( !adapterFormatList.Contains( displayMode.Format ) )
-            adapterFormatList.Add( displayMode.Format );
-
-        // Sort displaymode list
-        qsort( pAdapterInfo->displayModeList.GetData(),
-               pAdapterInfo->displayModeList.GetSize(), sizeof( D3DDISPLAYMODE ),
-               SortModesCallback );
-
-        // Get info for each device on this adapter
-        if( FAILED( EnumerateDevices( pAdapterInfo, &adapterFormatList ) ) )
-        {
-            delete pAdapterInfo;
-            continue;
-        }
-
-        // If at least one device on this adapter is available and compatible
-        // with the app, add the adapterInfo to the list
-        if( pAdapterInfo->deviceInfoList.GetSize() > 0 )
-        {
-            hr = m_AdapterInfoList.Add( pAdapterInfo );
-            if( FAILED( hr ) )
-                return hr;
-        }
-        else
-            delete pAdapterInfo;
-    }
-
-    //
-    // Check for 2 or more adapters with the same name. Append the name
-    // with some instance number if that's the case to help distinguish
-    // them.
-    //
-    bool bUniqueDesc = true;
-    CD3D9EnumAdapterInfo* pAdapterInfo;
-    for( int i = 0; i < m_AdapterInfoList.GetSize(); i++ )
-    {
-        CD3D9EnumAdapterInfo* pAdapterInfo1 = m_AdapterInfoList.GetAt( i );
-
-        for( int j = i + 1; j < m_AdapterInfoList.GetSize(); j++ )
-        {
-            CD3D9EnumAdapterInfo* pAdapterInfo2 = m_AdapterInfoList.GetAt( j );
-            if( _stricmp( pAdapterInfo1->AdapterIdentifier.Description,
-                          pAdapterInfo2->AdapterIdentifier.Description ) == 0 )
-            {
-                bUniqueDesc = false;
-                break;
-            }
-        }
-
-        if( !bUniqueDesc )
-            break;
-    }
-
-    for( int i = 0; i < m_AdapterInfoList.GetSize(); i++ )
-    {
-        pAdapterInfo = m_AdapterInfoList.GetAt( i );
-
-        MultiByteToWideChar( CP_ACP, 0,
-                             pAdapterInfo->AdapterIdentifier.Description, -1,
-                             pAdapterInfo->szUniqueDescription, 100 );
-        pAdapterInfo->szUniqueDescription[100] = 0;
-
-        if( !bUniqueDesc )
-        {
-            WCHAR sz[100];
-            swprintf_s( sz, 100, L" (#%d)", pAdapterInfo->AdapterOrdinal );
-            wcscat_s( pAdapterInfo->szUniqueDescription, 256, sz );
-
-        }
-    }
-
-    return S_OK;
-}
-
-
-
-//--------------------------------------------------------------------------------------
-// Enumerates D3D devices for a particular adapter.
-//--------------------------------------------------------------------------------------
-HRESULT CD3D9Enumeration::EnumerateDevices( CD3D9EnumAdapterInfo* pAdapterInfo,
-                                            CGrowableArray <D3DFORMAT>* pAdapterFormatList )
-{
-    HRESULT hr;
-
-    const D3DDEVTYPE devTypeArray[] =
-    {
-        D3DDEVTYPE_HAL,
-        D3DDEVTYPE_SW,
-        D3DDEVTYPE_REF
-    };
-    const UINT devTypeArrayCount = sizeof( devTypeArray ) / sizeof( devTypeArray[0] );
-
-    // Enumerate each Direct3D device type
-    for( UINT iDeviceType = 0; iDeviceType < devTypeArrayCount; iDeviceType++ )
-    {
-        CD3D9EnumDeviceInfo* pDeviceInfo = new CD3D9EnumDeviceInfo;
-        if( pDeviceInfo == NULL )
-            return E_OUTOFMEMORY;
-
-        // Fill struct w/ AdapterOrdinal and D3DDEVTYPE
-        pDeviceInfo->AdapterOrdinal = pAdapterInfo->AdapterOrdinal;
-        pDeviceInfo->DeviceType = devTypeArray[iDeviceType];
-
-        // Store device caps
-        if( FAILED( hr = m_pD3D->GetDeviceCaps( pAdapterInfo->AdapterOrdinal, pDeviceInfo->DeviceType,
-                                                &pDeviceInfo->Caps ) ) )
-        {
-            delete pDeviceInfo;
-            continue;
-        }
-
-        if( pDeviceInfo->DeviceType != D3DDEVTYPE_HAL )
-        {
-            // Create a temp device to verify that it is really possible to create a REF device 
-            // [the developer DirectX redist has to be installed]
-            D3DDISPLAYMODE Mode;
-            m_pD3D->GetAdapterDisplayMode( 0, &Mode );
-            D3DPRESENT_PARAMETERS pp;
-            ZeroMemory( &pp, sizeof( D3DPRESENT_PARAMETERS ) );
-            pp.BackBufferWidth = 1;
-            pp.BackBufferHeight = 1;
-            pp.BackBufferFormat = Mode.Format;
-            pp.BackBufferCount = 1;
-            pp.SwapEffect = D3DSWAPEFFECT_COPY;
-            pp.Windowed = TRUE;
-            pp.hDeviceWindow = DXUTGetHWNDFocus();
-            IDirect3DDevice9* pDevice = NULL;
-            if( FAILED( hr = m_pD3D->CreateDevice( pAdapterInfo->AdapterOrdinal, pDeviceInfo->DeviceType,
-                                                   DXUTGetHWNDFocus(),
-                                                   D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_FPU_PRESERVE, &pp,
-                                                   &pDevice ) ) )
-            {
-                delete pDeviceInfo;
-                continue;
-            }
-            SAFE_RELEASE( pDevice );
-        }
-
-        // Get info for each devicecombo on this device
-        if( FAILED( hr = EnumerateDeviceCombos( pAdapterInfo, pDeviceInfo, pAdapterFormatList ) ) )
-        {
-            delete pDeviceInfo;
-            continue;
-        }
-
-        // If at least one devicecombo for this device is found, 
-        // add the deviceInfo to the list
-        if( pDeviceInfo->deviceSettingsComboList.GetSize() > 0 )
-            pAdapterInfo->deviceInfoList.Add( pDeviceInfo );
-        else
-            delete pDeviceInfo;
-    }
-
-    return S_OK;
-}
-
-
-
-//--------------------------------------------------------------------------------------
-// Enumerates DeviceCombos for a particular device.
-//--------------------------------------------------------------------------------------
-HRESULT CD3D9Enumeration::EnumerateDeviceCombos( CD3D9EnumAdapterInfo* pAdapterInfo, CD3D9EnumDeviceInfo* pDeviceInfo,
-                                                 CGrowableArray <D3DFORMAT>* pAdapterFormatList )
-{
-    const D3DFORMAT backBufferFormatArray[] =
-    {
-        D3DFMT_A8R8G8B8,
-        D3DFMT_X8R8G8B8,
-        D3DFMT_A2R10G10B10,
-        D3DFMT_R5G6B5,
-        D3DFMT_A1R5G5B5,
-        D3DFMT_X1R5G5B5
-    };
-    const UINT backBufferFormatArrayCount = sizeof( backBufferFormatArray ) / sizeof( backBufferFormatArray[0] );
-
-    // See which adapter formats are supported by this device
-    for( int iFormat = 0; iFormat < pAdapterFormatList->GetSize(); iFormat++ )
-    {
-        D3DFORMAT adapterFormat = pAdapterFormatList->GetAt( iFormat );
-
-        for( UINT iBackBufferFormat = 0; iBackBufferFormat < backBufferFormatArrayCount; iBackBufferFormat++ )
-        {
-            D3DFORMAT backBufferFormat = backBufferFormatArray[iBackBufferFormat];
-
-            for( int nWindowed = 0; nWindowed < 2; nWindowed++ )
-            {
-                if( !nWindowed && pAdapterInfo->displayModeList.GetSize() == 0 )
-                    continue;
-
-                if( FAILED( m_pD3D->CheckDeviceType( pAdapterInfo->AdapterOrdinal, pDeviceInfo->DeviceType,
-                                                     adapterFormat, backBufferFormat, nWindowed ) ) )
-                {
-                    continue;
-                }
-
-                if( m_bRequirePostPixelShaderBlending )
-                {
-                    // If the backbuffer format doesn't support D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
-                    // then alpha test, pixel fog, render-target blending, color write enable, and dithering. 
-                    // are not supported.
-                    if( FAILED( m_pD3D->CheckDeviceFormat( pAdapterInfo->AdapterOrdinal, pDeviceInfo->DeviceType,
-                                                           adapterFormat, D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING,
-                                                           D3DRTYPE_TEXTURE, backBufferFormat ) ) )
-                    {
-                        continue;
-                    }
-                }
-
-                // If an application callback function has been provided, make sure this device
-                // is acceptable to the app.
-                if( m_IsD3D9DeviceAcceptableFunc != NULL )
-                {
-                    if( !m_IsD3D9DeviceAcceptableFunc( &pDeviceInfo->Caps, adapterFormat, backBufferFormat,
-                                                       FALSE != nWindowed, m_pIsD3D9DeviceAcceptableFuncUserContext ) )
-                        continue;
-                }
-
-                // At this point, we have an adapter/device/adapterformat/backbufferformat/iswindowed
-                // DeviceCombo that is supported by the system and acceptable to the app. We still 
-                // need to find one or more suitable depth/stencil buffer format,
-                // multisample type, and present interval.
-                CD3D9EnumDeviceSettingsCombo* pDeviceCombo = new CD3D9EnumDeviceSettingsCombo;
-                if( pDeviceCombo == NULL )
-                    return E_OUTOFMEMORY;
-
-                pDeviceCombo->AdapterOrdinal = pAdapterInfo->AdapterOrdinal;
-                pDeviceCombo->DeviceType = pDeviceInfo->DeviceType;
-                pDeviceCombo->AdapterFormat = adapterFormat;
-                pDeviceCombo->BackBufferFormat = backBufferFormat;
-                pDeviceCombo->Windowed = ( nWindowed != 0 );
-
-                BuildDepthStencilFormatList( pDeviceCombo );
-                BuildMultiSampleTypeList( pDeviceCombo );
-                if( pDeviceCombo->multiSampleTypeList.GetSize() == 0 )
-                {
-                    delete pDeviceCombo;
-                    continue;
-                }
-                BuildDSMSConflictList( pDeviceCombo );
-                BuildPresentIntervalList( pDeviceInfo, pDeviceCombo );
-                pDeviceCombo->pAdapterInfo = pAdapterInfo;
-                pDeviceCombo->pDeviceInfo = pDeviceInfo;
-
-                if( FAILED( pDeviceInfo->deviceSettingsComboList.Add( pDeviceCombo ) ) )
-                    delete pDeviceCombo;
-            }
-        }
-    }
-
-    return S_OK;
-}
-
-
-
-//--------------------------------------------------------------------------------------
-// Adds all depth/stencil formats that are compatible with the device 
-//       and app to the given D3DDeviceCombo.
-//--------------------------------------------------------------------------------------
-void CD3D9Enumeration::BuildDepthStencilFormatList( CD3D9EnumDeviceSettingsCombo* pDeviceCombo )
-{
-    D3DFORMAT depthStencilFmt;
-    for( int idsf = 0; idsf < m_DepthStencilPossibleList.GetSize(); idsf++ )
-    {
-        depthStencilFmt = m_DepthStencilPossibleList.GetAt( idsf );
-        if( SUCCEEDED( m_pD3D->CheckDeviceFormat( pDeviceCombo->AdapterOrdinal,
-                                                  pDeviceCombo->DeviceType, pDeviceCombo->AdapterFormat,
-                                                  D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, depthStencilFmt ) ) )
-        {
-            if( SUCCEEDED( m_pD3D->CheckDepthStencilMatch( pDeviceCombo->AdapterOrdinal,
-                                                           pDeviceCombo->DeviceType, pDeviceCombo->AdapterFormat,
-                                                           pDeviceCombo->BackBufferFormat, depthStencilFmt ) ) )
-            {
-                pDeviceCombo->depthStencilFormatList.Add( depthStencilFmt );
-            }
-        }
-    }
-}
-
-
-
-
-//--------------------------------------------------------------------------------------
-// Adds all multisample types that are compatible with the device and app to
-//       the given D3DDeviceCombo.
-//--------------------------------------------------------------------------------------
-void CD3D9Enumeration::BuildMultiSampleTypeList( CD3D9EnumDeviceSettingsCombo* pDeviceCombo )
-{
-    D3DMULTISAMPLE_TYPE msType;
-    DWORD msQuality;
-    for( int imst = 0; imst < m_MultiSampleTypeList.GetSize(); imst++ )
-    {
-        msType = m_MultiSampleTypeList.GetAt( imst );
-        if( SUCCEEDED( m_pD3D->CheckDeviceMultiSampleType( pDeviceCombo->AdapterOrdinal,
-                                                           pDeviceCombo->DeviceType, pDeviceCombo->BackBufferFormat,
-                                                           pDeviceCombo->Windowed, msType, &msQuality ) ) )
-        {
-            pDeviceCombo->multiSampleTypeList.Add( msType );
-            if( msQuality > m_nMultisampleQualityMax + 1 )
-                msQuality = m_nMultisampleQualityMax + 1;
-            pDeviceCombo->multiSampleQualityList.Add( msQuality );
-        }
-    }
-}
-
-
-
-
-//--------------------------------------------------------------------------------------
-// Find any conflicts between the available depth/stencil formats and
-//       multisample types.
-//--------------------------------------------------------------------------------------
-void CD3D9Enumeration::BuildDSMSConflictList( CD3D9EnumDeviceSettingsCombo* pDeviceCombo )
-{
-    CD3D9EnumDSMSConflict DSMSConflict;
-
-    for( int iDS = 0; iDS < pDeviceCombo->depthStencilFormatList.GetSize(); iDS++ )
-    {
-        D3DFORMAT dsFmt = pDeviceCombo->depthStencilFormatList.GetAt( iDS );
-
-        for( int iMS = 0; iMS < pDeviceCombo->multiSampleTypeList.GetSize(); iMS++ )
-        {
-            D3DMULTISAMPLE_TYPE msType = pDeviceCombo->multiSampleTypeList.GetAt( iMS );
-
-            if( FAILED( m_pD3D->CheckDeviceMultiSampleType( pDeviceCombo->AdapterOrdinal, pDeviceCombo->DeviceType,
-                                                            dsFmt, pDeviceCombo->Windowed, msType, NULL ) ) )
-            {
-                DSMSConflict.DSFormat = dsFmt;
-                DSMSConflict.MSType = msType;
-                pDeviceCombo->DSMSConflictList.Add( DSMSConflict );
-            }
-        }
-    }
-}
-
-
-//--------------------------------------------------------------------------------------
-// Adds all present intervals that are compatible with the device and app 
-//       to the given D3DDeviceCombo.
-//--------------------------------------------------------------------------------------
-void CD3D9Enumeration::BuildPresentIntervalList( CD3D9EnumDeviceInfo* pDeviceInfo,
-                                                 CD3D9EnumDeviceSettingsCombo* pDeviceCombo )
-{
-    UINT pi;
-    for( int ipi = 0; ipi < m_PresentIntervalList.GetSize(); ipi++ )
-    {
-        pi = m_PresentIntervalList.GetAt( ipi );
-        if( pDeviceCombo->Windowed )
-        {
-            if( pi == D3DPRESENT_INTERVAL_TWO ||
-                pi == D3DPRESENT_INTERVAL_THREE ||
-                pi == D3DPRESENT_INTERVAL_FOUR )
-            {
-                // These intervals are not supported in windowed mode.
-                continue;
-            }
-        }
-        // Note that D3DPRESENT_INTERVAL_DEFAULT is zero, so you
-        // can't do a caps check for it -- it is always available.
-        if( pi == D3DPRESENT_INTERVAL_DEFAULT ||
-            ( pDeviceInfo->Caps.PresentationIntervals & pi ) )
-        {
-            pDeviceCombo->presentIntervalList.Add( pi );
-        }
-    }
-}
-
-
-
-//--------------------------------------------------------------------------------------
-// Release all the allocated CD3D9EnumAdapterInfo objects and empty the list
-//--------------------------------------------------------------------------------------
-void CD3D9Enumeration::ClearAdapterInfoList()
-{
-    CD3D9EnumAdapterInfo* pAdapterInfo;
-    for( int i = 0; i < m_AdapterInfoList.GetSize(); i++ )
-    {
-        pAdapterInfo = m_AdapterInfoList.GetAt( i );
-        delete pAdapterInfo;
-    }
-
-    m_AdapterInfoList.RemoveAll();
-}
-
-
-
-//--------------------------------------------------------------------------------------
-// Call GetAdapterInfoList() after Enumerate() to get a STL vector of 
-//       CD3D9EnumAdapterInfo* 
-//--------------------------------------------------------------------------------------
-CGrowableArray <CD3D9EnumAdapterInfo*>* CD3D9Enumeration::GetAdapterInfoList()
-{
-    return &m_AdapterInfoList;
-}
-
-
-
-//--------------------------------------------------------------------------------------
-CD3D9EnumAdapterInfo* CD3D9Enumeration::GetAdapterInfo( UINT AdapterOrdinal )
-{
-    for( int iAdapter = 0; iAdapter < m_AdapterInfoList.GetSize(); iAdapter++ )
-    {
-        CD3D9EnumAdapterInfo* pAdapterInfo = m_AdapterInfoList.GetAt( iAdapter );
-        if( pAdapterInfo->AdapterOrdinal == AdapterOrdinal )
-            return pAdapterInfo;
-    }
-
-    return NULL;
-}
-
-
-//--------------------------------------------------------------------------------------
-CD3D9EnumDeviceInfo* CD3D9Enumeration::GetDeviceInfo( UINT AdapterOrdinal, D3DDEVTYPE DeviceType )
-{
-    CD3D9EnumAdapterInfo* pAdapterInfo = GetAdapterInfo( AdapterOrdinal );
-    if( pAdapterInfo )
-    {
-        for( int iDeviceInfo = 0; iDeviceInfo < pAdapterInfo->deviceInfoList.GetSize(); iDeviceInfo++ )
-        {
-            CD3D9EnumDeviceInfo* pDeviceInfo = pAdapterInfo->deviceInfoList.GetAt( iDeviceInfo );
-            if( pDeviceInfo->DeviceType == DeviceType )
-                return pDeviceInfo;
-        }
-    }
-
-    return NULL;
-}
-
-
-//--------------------------------------------------------------------------------------
-// 
-//--------------------------------------------------------------------------------------
-CD3D9EnumDeviceSettingsCombo* CD3D9Enumeration::GetDeviceSettingsCombo( UINT AdapterOrdinal, D3DDEVTYPE DeviceType,
-                                                                        D3DFORMAT AdapterFormat,
-                                                                        D3DFORMAT BackBufferFormat, BOOL bWindowed )
-{
-    CD3D9EnumDeviceInfo* pDeviceInfo = GetDeviceInfo( AdapterOrdinal, DeviceType );
-    if( pDeviceInfo )
-    {
-        for( int iDeviceCombo = 0; iDeviceCombo < pDeviceInfo->deviceSettingsComboList.GetSize(); iDeviceCombo++ )
-        {
-            CD3D9EnumDeviceSettingsCombo* pDeviceSettingsCombo = pDeviceInfo->deviceSettingsComboList.GetAt(
-                iDeviceCombo );
-            if( pDeviceSettingsCombo->AdapterFormat == AdapterFormat &&
-                pDeviceSettingsCombo->BackBufferFormat == BackBufferFormat &&
-                pDeviceSettingsCombo->Windowed == bWindowed )
-                return pDeviceSettingsCombo;
-        }
-    }
-
-    return NULL;
-}
-
-
-//--------------------------------------------------------------------------------------
-// Returns the number of color channel bits in the specified D3DFORMAT
-//--------------------------------------------------------------------------------------
-UINT WINAPI DXUTGetD3D9ColorChannelBits( D3DFORMAT fmt )
-{
-    switch( fmt )
-    {
-        case D3DFMT_R8G8B8:
-            return 8;
-        case D3DFMT_A8R8G8B8:
-            return 8;
-        case D3DFMT_X8R8G8B8:
-            return 8;
-        case D3DFMT_R5G6B5:
-            return 5;
-        case D3DFMT_X1R5G5B5:
-            return 5;
-        case D3DFMT_A1R5G5B5:
-            return 5;
-        case D3DFMT_A4R4G4B4:
-            return 4;
-        case D3DFMT_R3G3B2:
-            return 2;
-        case D3DFMT_A8R3G3B2:
-            return 2;
-        case D3DFMT_X4R4G4B4:
-            return 4;
-        case D3DFMT_A2B10G10R10:
-            return 10;
-        case D3DFMT_A8B8G8R8:
-            return 8;
-        case D3DFMT_A2R10G10B10:
-            return 10;
-        case D3DFMT_A16B16G16R16:
-            return 16;
-        default:
-            return 0;
-    }
-}
-
-
-//--------------------------------------------------------------------------------------
-// Returns the number of alpha channel bits in the specified D3DFORMAT
-//--------------------------------------------------------------------------------------
-UINT WINAPI DXUTGetAlphaChannelBits( D3DFORMAT fmt )
-{
-    switch( fmt )
-    {
-        case D3DFMT_R8G8B8:
-            return 0;
-        case D3DFMT_A8R8G8B8:
-            return 8;
-        case D3DFMT_X8R8G8B8:
-            return 0;
-        case D3DFMT_R5G6B5:
-            return 0;
-        case D3DFMT_X1R5G5B5:
-            return 0;
-        case D3DFMT_A1R5G5B5:
-            return 1;
-        case D3DFMT_A4R4G4B4:
-            return 4;
-        case D3DFMT_R3G3B2:
-            return 0;
-        case D3DFMT_A8R3G3B2:
-            return 8;
-        case D3DFMT_X4R4G4B4:
-            return 0;
-        case D3DFMT_A2B10G10R10:
-            return 2;
-        case D3DFMT_A8B8G8R8:
-            return 8;
-        case D3DFMT_A2R10G10B10:
-            return 2;
-        case D3DFMT_A16B16G16R16:
-            return 16;
-        default:
-            return 0;
-    }
-}
-
-
-//--------------------------------------------------------------------------------------
-// Returns the number of depth bits in the specified D3DFORMAT
-//--------------------------------------------------------------------------------------
-UINT WINAPI DXUTGetDepthBits( D3DFORMAT fmt )
-{
-    switch( fmt )
-    {
-        case D3DFMT_D32F_LOCKABLE:
-        case D3DFMT_D32:
-            return 32;
-
-        case D3DFMT_D24X8:
-        case D3DFMT_D24S8:
-        case D3DFMT_D24X4S4:
-        case D3DFMT_D24FS8:
-            return 24;
-
-        case D3DFMT_D16_LOCKABLE:
-        case D3DFMT_D16:
-            return 16;
-
-        case D3DFMT_D15S1:
-            return 15;
-
-        default:
-            return 0;
-    }
-}
-
-
-
-
-//--------------------------------------------------------------------------------------
-// Returns the number of stencil bits in the specified D3DFORMAT
-//--------------------------------------------------------------------------------------
-UINT WINAPI DXUTGetStencilBits( D3DFORMAT fmt )
-{
-    switch( fmt )
-    {
-        case D3DFMT_D16_LOCKABLE:
-        case D3DFMT_D16:
-        case D3DFMT_D32F_LOCKABLE:
-        case D3DFMT_D32:
-        case D3DFMT_D24X8:
-            return 0;
-
-        case D3DFMT_D15S1:
-            return 1;
-
-        case D3DFMT_D24X4S4:
-            return 4;
-
-        case D3DFMT_D24S8:
-        case D3DFMT_D24FS8:
-            return 8;
-
-        default:
-            return 0;
-    }
-}
-
-
-
-//--------------------------------------------------------------------------------------
-// Used to sort D3DDISPLAYMODEs
-//--------------------------------------------------------------------------------------
-static int __cdecl SortModesCallback( const void* arg1, const void* arg2 )
-{
-    D3DDISPLAYMODE* pdm1 = ( D3DDISPLAYMODE* )arg1;
-    D3DDISPLAYMODE* pdm2 = ( D3DDISPLAYMODE* )arg2;
-
-    if( pdm1->Width > pdm2->Width )
-        return 1;
-    if( pdm1->Width < pdm2->Width )
-        return -1;
-    if( pdm1->Height > pdm2->Height )
-        return 1;
-    if( pdm1->Height < pdm2->Height )
-        return -1;
-    if( pdm1->Format > pdm2->Format )
-        return 1;
-    if( pdm1->Format < pdm2->Format )
-        return -1;
-    if( pdm1->RefreshRate > pdm2->RefreshRate )
-        return 1;
-    if( pdm1->RefreshRate < pdm2->RefreshRate )
-        return -1;
-    return 0;
-}
-
-
-
-//--------------------------------------------------------------------------------------
-CD3D9EnumAdapterInfo::~CD3D9EnumAdapterInfo( void )
-{
-    CD3D9EnumDeviceInfo* pDeviceInfo;
-    for( int i = 0; i < deviceInfoList.GetSize(); i++ )
-    {
-        pDeviceInfo = deviceInfoList.GetAt( i );
-        delete pDeviceInfo;
-    }
-    deviceInfoList.RemoveAll();
-}
-
-
-
-
-//--------------------------------------------------------------------------------------
-CD3D9EnumDeviceInfo::~CD3D9EnumDeviceInfo( void )
-{
-    CD3D9EnumDeviceSettingsCombo* pDeviceCombo;
-    for( int i = 0; i < deviceSettingsComboList.GetSize(); i++ )
-    {
-        pDeviceCombo = deviceSettingsComboList.GetAt( i );
-        delete pDeviceCombo;
-    }
-    deviceSettingsComboList.RemoveAll();
-}
-
-
-//--------------------------------------------------------------------------------------
-void CD3D9Enumeration::ResetPossibleDepthStencilFormats()
-{
-    m_DepthStencilPossibleList.RemoveAll();
-    m_DepthStencilPossibleList.Add( D3DFMT_D16 );
-    m_DepthStencilPossibleList.Add( D3DFMT_D15S1 );
-    m_DepthStencilPossibleList.Add( D3DFMT_D24X8 );
-    m_DepthStencilPossibleList.Add( D3DFMT_D24S8 );
-    m_DepthStencilPossibleList.Add( D3DFMT_D24X4S4 );
-    m_DepthStencilPossibleList.Add( D3DFMT_D32 );
-}
-
-
-//--------------------------------------------------------------------------------------
-CGrowableArray <D3DFORMAT>* CD3D9Enumeration::GetPossibleDepthStencilFormatList()
-{
-    return &m_DepthStencilPossibleList;
-}
-
-
-//--------------------------------------------------------------------------------------
-CGrowableArray <D3DMULTISAMPLE_TYPE>* CD3D9Enumeration::GetPossibleMultisampleTypeList()
-{
-    return &m_MultiSampleTypeList;
-}
-
-
-//--------------------------------------------------------------------------------------
-void CD3D9Enumeration::ResetPossibleMultisampleTypeList()
-{
-    m_MultiSampleTypeList.RemoveAll();
-    m_MultiSampleTypeList.Add( D3DMULTISAMPLE_NONE );
-    m_MultiSampleTypeList.Add( D3DMULTISAMPLE_NONMASKABLE );
-    m_MultiSampleTypeList.Add( D3DMULTISAMPLE_2_SAMPLES );
-    m_MultiSampleTypeList.Add( D3DMULTISAMPLE_3_SAMPLES );
-    m_MultiSampleTypeList.Add( D3DMULTISAMPLE_4_SAMPLES );
-    m_MultiSampleTypeList.Add( D3DMULTISAMPLE_5_SAMPLES );
-    m_MultiSampleTypeList.Add( D3DMULTISAMPLE_6_SAMPLES );
-    m_MultiSampleTypeList.Add( D3DMULTISAMPLE_7_SAMPLES );
-    m_MultiSampleTypeList.Add( D3DMULTISAMPLE_8_SAMPLES );
-    m_MultiSampleTypeList.Add( D3DMULTISAMPLE_9_SAMPLES );
-    m_MultiSampleTypeList.Add( D3DMULTISAMPLE_10_SAMPLES );
-    m_MultiSampleTypeList.Add( D3DMULTISAMPLE_11_SAMPLES );
-    m_MultiSampleTypeList.Add( D3DMULTISAMPLE_12_SAMPLES );
-    m_MultiSampleTypeList.Add( D3DMULTISAMPLE_13_SAMPLES );
-    m_MultiSampleTypeList.Add( D3DMULTISAMPLE_14_SAMPLES );
-    m_MultiSampleTypeList.Add( D3DMULTISAMPLE_15_SAMPLES );
-    m_MultiSampleTypeList.Add( D3DMULTISAMPLE_16_SAMPLES );
-}
-
-
-//--------------------------------------------------------------------------------------
-void CD3D9Enumeration::GetPossibleVertexProcessingList( bool* pbSoftwareVP, bool* pbHardwareVP, bool* pbPureHarewareVP,
-                                                        bool* pbMixedVP )
-{
-    *pbSoftwareVP = m_bSoftwareVP;
-    *pbHardwareVP = m_bHardwareVP;
-    *pbPureHarewareVP = m_bPureHarewareVP;
-    *pbMixedVP = m_bMixedVP;
-}
-
-
-//--------------------------------------------------------------------------------------
-void CD3D9Enumeration::SetPossibleVertexProcessingList( bool bSoftwareVP, bool bHardwareVP, bool bPureHarewareVP,
-                                                        bool bMixedVP )
-{
-    m_bSoftwareVP = bSoftwareVP;
-    m_bHardwareVP = bHardwareVP;
-    m_bPureHarewareVP = bPureHarewareVP;
-    m_bMixedVP = bMixedVP;
-}
-
-
-//--------------------------------------------------------------------------------------
-CGrowableArray <UINT>* CD3D9Enumeration::GetPossiblePresentIntervalList()
-{
-    return &m_PresentIntervalList;
-}
-
-
-//--------------------------------------------------------------------------------------
-void CD3D9Enumeration::ResetPossiblePresentIntervalList()
-{
-    m_PresentIntervalList.RemoveAll();
-    m_PresentIntervalList.Add( D3DPRESENT_INTERVAL_IMMEDIATE );
-    m_PresentIntervalList.Add( D3DPRESENT_INTERVAL_DEFAULT );
-    m_PresentIntervalList.Add( D3DPRESENT_INTERVAL_ONE );
-    m_PresentIntervalList.Add( D3DPRESENT_INTERVAL_TWO );
-    m_PresentIntervalList.Add( D3DPRESENT_INTERVAL_THREE );
-    m_PresentIntervalList.Add( D3DPRESENT_INTERVAL_FOUR );
-}
-
-
-//--------------------------------------------------------------------------------------
-void CD3D9Enumeration::SetResolutionMinMax( UINT nMinWidth, UINT nMinHeight,
-                                            UINT nMaxWidth, UINT nMaxHeight )
-{
-    m_nMinWidth = nMinWidth;
-    m_nMinHeight = nMinHeight;
-    m_nMaxWidth = nMaxWidth;
-    m_nMaxHeight = nMaxHeight;
-}
-
-
-//--------------------------------------------------------------------------------------
-void CD3D9Enumeration::SetRefreshMinMax( UINT nMin, UINT nMax )
-{
-    m_nRefreshMin = nMin;
-    m_nRefreshMax = nMax;
-}
-
-
-//--------------------------------------------------------------------------------------
-void CD3D9Enumeration::SetMultisampleQualityMax( UINT nMax )
-{
-    if( nMax > 0xFFFF )
-        nMax = 0xFFFF;
-    m_nMultisampleQualityMax = nMax;
-}
-
-
-
-//--------------------------------------------------------------------------------------
-// Returns a ranking number that describes how closely this device 
-// combo matches the optimal combo based on the match options and the optimal device settings
-//--------------------------------------------------------------------------------------
-float DXUTRankD3D9DeviceCombo( CD3D9EnumDeviceSettingsCombo* pDeviceSettingsCombo,
-                               DXUTD3D9DeviceSettings* pOptimalDeviceSettings,
-                               D3DDISPLAYMODE* pAdapterDesktopDisplayMode, 
-                               int &bestModeIndex,
-                               int &bestMSAAIndex
-                               )
-{
-    float fCurRanking = 0.0f;
-
-    // Arbitrary weights.  Gives preference to the ordinal, device type, and windowed
-    const float fAdapterOrdinalWeight   = 1000.0f;
-    const float fDeviceTypeWeight       = 100.0f;
-    const float fWindowWeight           = 10.0f;
-    const float fAdapterFormatWeight    = 1.0f;
-    const float fVertexProcessingWeight = 1.0f;
-    const float fResolutionWeight       = 1.0f;
-    const float fBackBufferFormatWeight = 1.0f;
-    const float fMultiSampleWeight      = 1.0f;
-    const float fDepthStencilWeight     = 1.0f;
-    const float fRefreshRateWeight      = 1.0f;
-    const float fPresentIntervalWeight  = 1.0f;
-
-    //---------------------
-    // Adapter ordinal
-    //---------------------
-    if( pDeviceSettingsCombo->AdapterOrdinal == pOptimalDeviceSettings->AdapterOrdinal )
-        fCurRanking += fAdapterOrdinalWeight;
-
-    //---------------------
-    // Device type
-    //---------------------
-    if( pDeviceSettingsCombo->DeviceType == pOptimalDeviceSettings->DeviceType )
-        fCurRanking += fDeviceTypeWeight;
-    // Slightly prefer HAL 
-    if( pDeviceSettingsCombo->DeviceType == D3DDEVTYPE_HAL )
-        fCurRanking += 0.1f;
-
-    //---------------------
-    // Windowed
-    //---------------------
-    if( pDeviceSettingsCombo->Windowed == pOptimalDeviceSettings->pp.Windowed )
-        fCurRanking += fWindowWeight;
-
-    //---------------------
-    // Adapter format
-    //---------------------
-    if( pDeviceSettingsCombo->AdapterFormat == pOptimalDeviceSettings->AdapterFormat )
-    {
-        fCurRanking += fAdapterFormatWeight;
-    }
-    else
-    {
-        int nBitDepthDelta = abs( ( long )DXUTGetD3D9ColorChannelBits( pDeviceSettingsCombo->AdapterFormat ) -
-                                  ( long )DXUTGetD3D9ColorChannelBits( pOptimalDeviceSettings->AdapterFormat ) );
-        float fScale = __max( 0.9f - ( float )nBitDepthDelta * 0.2f, 0.0f );
-        fCurRanking += fScale * fAdapterFormatWeight;
-    }
-
-    if( !pDeviceSettingsCombo->Windowed )
-    {
-        // Slightly prefer when it matches the desktop format or is D3DFMT_X8R8G8B8
-        bool bAdapterOptimalMatch;
-        if( DXUTGetD3D9ColorChannelBits( pAdapterDesktopDisplayMode->Format ) >= 8 )
-            bAdapterOptimalMatch = ( pDeviceSettingsCombo->AdapterFormat == pAdapterDesktopDisplayMode->Format );
-        else
-            bAdapterOptimalMatch = ( pDeviceSettingsCombo->AdapterFormat == D3DFMT_X8R8G8B8 );
-
-        if( bAdapterOptimalMatch )
-            fCurRanking += 0.1f;
-    }
-
-    //---------------------
-    // Vertex processing
-    //---------------------
-    if( ( pOptimalDeviceSettings->BehaviorFlags & D3DCREATE_HARDWARE_VERTEXPROCESSING ) != 0 ||
-        ( pOptimalDeviceSettings->BehaviorFlags & D3DCREATE_MIXED_VERTEXPROCESSING ) != 0 )
-    {
-        if( ( pDeviceSettingsCombo->pDeviceInfo->Caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT ) != 0 )
-            fCurRanking += fVertexProcessingWeight;
-    }
-    // Slightly prefer HW T&L
-    if( ( pDeviceSettingsCombo->pDeviceInfo->Caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT ) != 0 )
-        fCurRanking += 0.1f;
-
-    //---------------------
-    // Resolution
-    //---------------------
-    bool bResolutionFound = false;
-    unsigned int best = 0xffffffff;
-    bestModeIndex=0;
-
-
-
-
-
-    for( int idm = 0; idm < pDeviceSettingsCombo->pAdapterInfo->displayModeList.GetSize(); idm++ )
-    {
-        D3DDISPLAYMODE displayMode = pDeviceSettingsCombo->pAdapterInfo->displayModeList.GetAt( idm );
-        if( displayMode.Format != pDeviceSettingsCombo->AdapterFormat )
-            continue;
-        if( displayMode.Width == pOptimalDeviceSettings->pp.BackBufferWidth &&
-            displayMode.Height == pOptimalDeviceSettings->pp.BackBufferHeight )
-            bResolutionFound = true;
-
-        unsigned int current = 
-            (UINT) abs ((int)displayMode.Width  - (int)pOptimalDeviceSettings->pp.BackBufferWidth) + 
-            (UINT) abs ((int)displayMode.Height - (int)pOptimalDeviceSettings->pp.BackBufferHeight );
-        if (current < best) {
-            best = current;
-            bestModeIndex= idm;
-
-        }
-
-
-    }
-    if( bResolutionFound )
-        fCurRanking += fResolutionWeight;
-
-    //---------------------
-    // Back buffer format
-    //---------------------
-    if( pDeviceSettingsCombo->BackBufferFormat == pOptimalDeviceSettings->pp.BackBufferFormat )
-    {
-        fCurRanking += fBackBufferFormatWeight;
-    }
-    else
-    {
-        int nBitDepthDelta = abs( ( long )DXUTGetD3D9ColorChannelBits( pDeviceSettingsCombo->BackBufferFormat ) -
-                                  ( long )DXUTGetD3D9ColorChannelBits( pOptimalDeviceSettings->pp.BackBufferFormat ) );
-        float fScale = __max( 0.9f - ( float )nBitDepthDelta * 0.2f, 0.0f );
-        fCurRanking += fScale * fBackBufferFormatWeight;
-    }
-
-    // Check if this back buffer format is the same as 
-    // the adapter format since this is preferred.
-    bool bAdapterMatchesBB = ( pDeviceSettingsCombo->BackBufferFormat == pDeviceSettingsCombo->AdapterFormat );
-    if( bAdapterMatchesBB )
-        fCurRanking += 0.1f;
-
-    //---------------------
-    // Back buffer count
-    //---------------------
-    // No caps for the back buffer count
-
-    //---------------------
-    // Multisample
-    //---------------------
-    bool bMultiSampleFound = false;
-    for( int i = 0; i < pDeviceSettingsCombo->multiSampleTypeList.GetSize(); i++ )
-    {
-        D3DMULTISAMPLE_TYPE msType = pDeviceSettingsCombo->multiSampleTypeList.GetAt( i );
-        DWORD msQuality = pDeviceSettingsCombo->multiSampleQualityList.GetAt( i );
-
-        if( msType == pOptimalDeviceSettings->pp.MultiSampleType &&
-            msQuality > pOptimalDeviceSettings->pp.MultiSampleQuality )
-        {
-            bMultiSampleFound = true;
-            bestMSAAIndex = i;
-            break;
-        }
-    }
-    if( bMultiSampleFound )
-        fCurRanking += fMultiSampleWeight;
-
-    //---------------------
-    // Swap effect
-    //---------------------
-    // No caps for swap effects
-
-    //---------------------
-    // Depth stencil 
-    //---------------------
-    if( pDeviceSettingsCombo->depthStencilFormatList.Contains( pOptimalDeviceSettings->pp.AutoDepthStencilFormat ) )
-        fCurRanking += fDepthStencilWeight;
-
-    //---------------------
-    // Present flags
-    //---------------------
-    // No caps for the present flags
-
-    //---------------------
-    // Refresh rate
-    //---------------------
-    bool bRefreshFound = false;
-    for( int idm = 0; idm < pDeviceSettingsCombo->pAdapterInfo->displayModeList.GetSize(); idm++ )
-    {
-        D3DDISPLAYMODE displayMode = pDeviceSettingsCombo->pAdapterInfo->displayModeList.GetAt( idm );
-        if( displayMode.Format != pDeviceSettingsCombo->AdapterFormat )
-            continue;
-        if( displayMode.RefreshRate == pOptimalDeviceSettings->pp.FullScreen_RefreshRateInHz )
-            bRefreshFound = true;
-    }
-    if( bRefreshFound )
-        fCurRanking += fRefreshRateWeight;
-
-    //---------------------
-    // Present interval
-    //---------------------
-    // If keep present interval then check that the present interval is supported by this combo
-    if( pDeviceSettingsCombo->presentIntervalList.Contains( pOptimalDeviceSettings->pp.PresentationInterval ) )
-        fCurRanking += fPresentIntervalWeight;
-
-    return fCurRanking;
-}
-