cDXEnumeration.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cDXEnumeration_H
#define _INC_cDXEnumeration_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cDXBase.h"
#include "GrayCore/include/cRefPtr.h"
#include "GrayCore/include/cArraySort.h"
#include "GrayCore/include/cString.h"
#include "GrayCore/include/cUnitTestDecl.h"
#include "GrayCore/include/cPair.h"
 
#ifdef USE_DX9
 
namespace Gray
{
        template <>
        COMPARE_t cValT::Compare<D3DDISPLAYMODE>(const D3DDISPLAYMODE& dm1, const D3DDISPLAYMODE& dm2);
};
 
namespace Gray3D
{
        class cDXEnumDevice;
        class cDXEnumAdapter;
        class cDXEnumeration;
 
        enum VertexProcessing_TYPE
        {
                VertexProcessing_SOFTWARE,                      
                VertexProcessing_MIXED,                         
                VertexProcessing_HARDWARE,                      
                VertexProcessing_PURE_HARDWARE,         
                VertexProcessing_QTY
        };
 
        struct GRAY3D_LINK cDXEnumBase // static
        {
                static UINT GRAYCALL GetColorChannelBits(D3DFORMAT eFormat);
                static UINT GRAYCALL GetAlphaChannelBits(D3DFORMAT eFormat);
                static UINT GRAYCALL GetDepthBits(D3DFORMAT eFormat);
                static UINT GRAYCALL GetStencilBits(D3DFORMAT eFormat);
                static DWORD GRAYCALL GetDeviceCreateFlags(VertexProcessing_TYPE eVertexProcessingType);
 
                static const D3DDEVTYPE k_aeDevTypes[]; 
                static const D3DFORMAT k_aeFormatAllowedAdapterList[]; // the formats i like. ignore devices that don't support one of these.
        };
 
        //**********************************************************************************************
        typedef cPair<D3DFORMAT, D3DMULTISAMPLE_TYPE> cDXEnumDSMSConflict;                      
 
        //**********************************************************************************************
        class GRAY3D_LINK cDXEnumCombo : public cRefBase, public cDXEnumBase
        {
 
        public:
                cDXEnumDevice* const m_pDevice;         
                D3DFORMAT m_eFormatAdapter;
                D3DFORMAT m_eFormatBackBuffer;
                bool m_bFullScreenMode;
 
                cArrayVal<D3DFORMAT> m_aDepthStencilFormatList; 
                cArrayVal<D3DMULTISAMPLE_TYPE> m_aMultiSampleTypeList; 
                cArrayVal<DWORD> m_aMultiSampleQualityList;             
                cArrayVal<cDXEnumDSMSConflict> m_aDSMSConflictList; 
                cArrayVal<VertexProcessing_TYPE> m_aVertexProcessingTypeList; 
                cArrayVal<UINT> m_aPresentIntervalList;                 
 
        public:
                cDXEnumCombo(cDXEnumDevice* pDevice, D3DFORMAT eFormatAdapter, D3DFORMAT eFormatBackBuffer, bool bFullScreenMode);
                ~cDXEnumCombo(void);
 
                cDXEnumDevice* get_Device() const noexcept
                {
                        return m_pDevice;
                }
                cDXEnumAdapter* get_Adapter() const;
                UINT get_AdapterOrdinal() const;
 
                bool isFullscreen() const noexcept
                {
                        return m_bFullScreenMode;
                }
 
                void BuildDSMSConflictList(IDirect3D9* pD3D);
                void BuildMultiSampleTypeList(IDirect3D9* pD3D);
                void BuildDepthStencilFormatList(const cDXEnumeration& rEnum);
 
                void BuildVertexProcessingTypeList(const cDXEnumeration& rEnum, const D3DCAPS9& Caps);
                void BuildPresentIntervalList(const D3DCAPS9& Caps);
        };
 
        typedef cRefPtr<cDXEnumCombo> cDXEnumComboPtr;
 
        //**********************************************************************************************
        class GRAY3D_LINK cDXEnumDevice : public cRefBase, public cDXEnumBase
        {
 
        public:
                cDXEnumAdapter* const m_pAdapter;       
                const D3DDEVTYPE m_eDevType;            
                D3DCAPS9 m_Caps;                                        
                cArrayRef<cDXEnumCombo> m_aDeviceComboList; 
 
        public:
                cDXEnumDevice(cDXEnumAdapter* pAdapter, D3DDEVTYPE eDevType, const D3DCAPS9& Caps);
                ~cDXEnumDevice(void);
 
                cDXEnumAdapter* get_Adapter() const noexcept
                {
                        return m_pAdapter;
                }
 
                UINT get_AdapterOrdinal() const;
                bool isPureHardware() const;
                HRESULT EnumerateDeviceCombos(const cDXEnumeration& rEnum, const cArrayVal<D3DFORMAT>& aAdapterFormats);
        };
 
        typedef cRefPtr<cDXEnumDevice> cDXEnumDevicePtr;
 
        //**********************************************************************************************
        class GRAY3D_LINK cDXEnumAdapter : public cRefBase, public cDXEnumBase
        {
 
        public:
                const UINT m_nAdapterOrdinal;           
                D3DADAPTER_IDENTIFIER9 m_AdapterIdentifier;                     
                cArraySortVal<D3DDISPLAYMODE> m_aDisplayModes;  
                cRefPtr<cDXEnumDevice> m_aDeviceInfoList[VertexProcessing_QTY];         
 
        public:
                cDXEnumAdapter(UINT nAdapterOrdinal, const D3DADAPTER_IDENTIFIER9& AdapterIdentifier);
                ~cDXEnumAdapter(void);
 
                void EnumerateAdapterFormats(const cDXEnumeration& rEnum, cArrayVal<D3DFORMAT>& aAdapterFormats);
                HRESULT EnumerateDevices(const cDXEnumeration& rEnum, const cArrayVal<D3DFORMAT>& aAdapterFormats);
 
                cString get_Desc() const
                {
                        return cString(this->m_AdapterIdentifier.Description, STRMAX(this->m_AdapterIdentifier.Description));
                }
        };
 
        typedef cRefPtr<cDXEnumAdapter> cDXEnumAdapterPtr;
 
        //**********************************************************************************************
        class GRAY3D_LINK cDXEnumeration
        {
 
        public:
                cIUnkPtr<IDirect3D9> m_pD3D;            
 
        public:
                // Filters
                // The following variables can be used to limit what modes, formats, etc. are enumerated.  
 
                UINT m_AppMinDepthBits;
                UINT m_AppMinStencilBits;
                bool m_bEnableAutoDepthStencil;
                bool m_AppUsesMixedVP;                  
 
                bool m_AppRequiresWindowed;             
                bool m_AppRequiresFullScreen;
 
                UINT m_AppMinFullScreenWidth;
                UINT m_AppMinFullScreenHeight;
                UINT m_AppMinColorChannelBits;  
                UINT m_AppMinAlphaChannelBits;  
 
                // results
                cArrayRef<cDXEnumAdapter> m_aAdapterInfoList;
                bool m_bDetectedNVidia;
                bool m_bDetectedNVidiaDebug;            // NVPerfHUD
 
        public:
                cDXEnumeration(IDirect3D9* pD3D = nullptr);
                ~cDXEnumeration();
 
                cDXEnumComboPtr FindWindowedCombo(const D3DDISPLAYMODE& DisplayMode, bool bRequireREF = false) const;
 
                virtual bool IsVertexProcessingAllowed(VertexProcessing_TYPE eVertexProcessingType, const D3DCAPS9& Caps, const cDXEnumCombo* pDeviceCombo) const;
 
                HRESULT EnumerateAdapter(UINT nAdapterOrdinal = 0);
                HRESULT EnumerateAdapters();
 
                UNITTEST_FRIEND(cDXEnumeration);
        };
}
 
#endif
#endif // cDXEnumeration