summaryrefslogtreecommitdiffhomepage
path: root/Stars45/VideoDX9Enum.h
blob: 91279aa311d07b9821547ffeb1c74c270252c452 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
/*  Starshatter: The Open Source Project
    Copyright (c) 2021-2022, 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