/*  Starshatter: The Open Source Project
    Copyright (c) 2021-2024, Starshatter: The Open Source Project Contributors
    Copyright (c) 2011-2012, Starshatter OpenSource Distribution Contributors
    Copyright (c) 1997-2006, Destroyer Studios LLC.

    AUTHOR:       John DiCamillo


    OVERVIEW
    ========
    Direct3D and Direct3D Video classes for DirectX 7
*/

#ifndef VideoDX9Enum_h
#define VideoDX9Enum_h

#include <d3d9.h>

#include "Video.h"
#include "List.h"
#include <vector>

// +--------------------------------------------------------------------+

class  VideoDX9Enum;
struct VideoDX9DisplayMode;
struct VideoDX9AdapterInfo;
struct VideoDX9DeviceInfo;
struct VideoDX9DSMSConflict;
struct VideoDX9DeviceCombo;
class  VideoSettings;

// +--------------------------------------------------------------------+

class VideoDX9Enum
{
public:
    enum VP_TYPE {
        SOFTWARE_VP,
        MIXED_VP,
        HARDWARE_VP,
        PURE_HARDWARE_VP
    };

    VideoDX9Enum(IDirect3D9* d3d9);
    ~VideoDX9Enum();

    void     SetDirect3D9(IDirect3D9* d3d9);

    HRESULT  Enumerate();
    bool     SuggestWindowSettings(VideoSettings* vs);
    bool     SuggestFullscreenSettings(VideoSettings* vs);

    int                  NumAdapters()  const { return adapter_info_list.size(); }
    void                 SelectAdapter(int index);
    VideoDX9AdapterInfo* GetAdapterInfo();
    VideoDX9DeviceInfo*  GetDeviceInfo(DWORD devtype);

    bool     IsModeSupported(int width, int height, int bpp) const;

    UINT     min_width;
    UINT     min_height;
    UINT     min_color_bits;
    UINT     min_alpha_bits;
    UINT     min_depth_bits;
    UINT     min_stencil_bits;

    bool     uses_depth_buffer;
    bool     uses_mixed_vp;
    bool     req_windowed;
    bool     req_fullscreen;

private:
    HRESULT  EnumerateDevices(VideoDX9AdapterInfo* adapter_info, std::vector<D3DFORMAT>& adapter_format_list);
    HRESULT  EnumerateDeviceCombos(VideoDX9DeviceInfo* device_info, std::vector<D3DFORMAT>& adapter_format_list);

    void     BuildDepthStencilFormatList(VideoDX9DeviceCombo* device_combo);
    void     BuildMultiSampleTypeList(VideoDX9DeviceCombo* device_combo);
    void     BuildDSMSConflictList(VideoDX9DeviceCombo* device_combo);
    void     BuildVertexProcessingTypeList(VideoDX9DeviceInfo* device_info, VideoDX9DeviceCombo* device_combo);
    void     BuildPresentIntervalList(VideoDX9DeviceInfo* device_info, VideoDX9DeviceCombo* device_combo);

    IDirect3D9*                d3d;
    std::vector<D3DFORMAT>     allowed_adapter_format_list;

    List<VideoDX9AdapterInfo>  adapter_info_list;
    int                        adapter_index;
};


// +--------------------------------------------------------------------+

struct VideoDX9AdapterInfo
{
    static const char* TYPENAME() { return "VideoDX9AdapterInfo"; }

    VideoDX9AdapterInfo();
    ~VideoDX9AdapterInfo();

    const char* GetDescription() const;

    int                        adapter_ordinal;
    D3DADAPTER_IDENTIFIER9     adapter_identifier;
    List<VideoDX9DisplayMode>  display_mode_list;
    List<VideoDX9DeviceInfo>   device_info_list;
};


// +--------------------------------------------------------------------+

struct VideoDX9DisplayMode
{
    static const char* TYPENAME() { return "VideoDX9DisplayMode"; }

    VideoDX9DisplayMode();
    VideoDX9DisplayMode(const VideoDX9DisplayMode& m);
    VideoDX9DisplayMode(const D3DDISPLAYMODE& m);

    int operator<(const VideoDX9DisplayMode& m) const;
    int operator<=(const VideoDX9DisplayMode& m) const;

    const char*          GetDescription() const;
    static const char*   D3DFormatToString(D3DFORMAT format);

    UINT        width;
    UINT        height;
    UINT        refresh;
    D3DFORMAT   format;
};


// +--------------------------------------------------------------------+

struct VideoDX9DeviceInfo
{
    static const char* TYPENAME() { return "VideoDX9DeviceInfo"; }

    VideoDX9DeviceInfo();
    ~VideoDX9DeviceInfo();

    int                        adapter_ordinal;
    D3DDEVTYPE                 device_type;
    D3DCAPS9                   caps;
    List<VideoDX9DeviceCombo>  device_combo_list;
};


// +--------------------------------------------------------------------+

struct VideoDX9FormatConflict
{
    static const char* TYPENAME() { return "VideoDX9FormatConflict"; }

    D3DFORMAT                  ds_format;
    D3DMULTISAMPLE_TYPE        multisample_type;
};


// +--------------------------------------------------------------------+

struct VideoDX9DeviceCombo
{
    VideoDX9DeviceCombo();
    ~VideoDX9DeviceCombo();

    int                  adapter_ordinal;
    D3DDEVTYPE           device_type;
    D3DFORMAT            adapter_format;
    D3DFORMAT            back_buffer_format;
    bool                 is_windowed;

    std::vector<int>                    vertex_processing_list;
    std::vector<D3DFORMAT>                depth_stencil_fmt_list;
    std::vector<D3DMULTISAMPLE_TYPE>    multisample_type_list;
    std::vector<DWORD>                    multisample_qual_list;
    std::vector<DWORD>                    present_interval_list;

    List<VideoDX9FormatConflict> conflict_list;
};

// +--------------------------------------------------------------------+

#endif  // VideoDX9Enum_h