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
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
|
/***************************************************************************
* Copyright (C) 2005-2019 by the FIFE team *
* http://www.fifengine.net *
* This file is part of FIFE. *
* *
* FIFE is free software; you can redistribute it and/or *
* modify it under the terms of the GNU Lesser General Public *
* License as published by the Free Software Foundation; either *
* version 2.1 of the License, or (at your option) any later version. *
* *
* This library is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
* Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU Lesser General Public *
* License along with this library; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA *
***************************************************************************/
#ifndef FIFE_DEVICECAPS_H
#define FIFE_DEVICECAPS_H
// Standard C++ library includes
#include <string>
#include <vector>
// Platform specific includes
// 3rd party library includes
// FIFE includes
// These includes are split up in two parts, separated by one empty line
// First block: files included from the FIFE root src directory
// Second block: files included from the same folder
#include "util/structures/rect.h"
namespace FIFE {
class ScreenMode {
public:
/** Default Constructor
* @note You shouldn't construct these objects yourself. This default
* constructor was provided because swig complained that was none.
*/
ScreenMode();
ScreenMode(uint16_t width, uint16_t height, uint16_t bpp, uint32_t SDLFlags);
ScreenMode(uint16_t width, uint16_t height, uint16_t bpp, uint16_t rate, uint32_t SDLFlags);
ScreenMode(const ScreenMode& rhs);
/** Destructor.
*/
~ScreenMode() {};
bool operator <(const ScreenMode& rhs) const;
/** Returns the width of the screen mode.
* @note If both width and height are 0 it means that ALL modes are available
* for use with the specified flags. Most likely this is a windowed mode.
*/
uint16_t getWidth() const { return m_width; };
/** Returns the height of the screen mode.
* @note If both width and height are 0 it means that ALL modes are available
* for use with the specified flags. Most likely this is a windowed mode.
*/
uint16_t getHeight() const { return m_height; };
/** Returns the number of bits per pixel this mode uses.
*/
uint16_t getBPP() const { return m_bpp; };
/** Returns the refresh rate in Hz of this mode.
*/
uint16_t getRefreshRate() const { return m_refreshRate; }
/** Returns the SDL flags used when testing this mode.
*/
uint32_t getSDLFlags() const { return m_SDLFlags; };
/** True if this is a fullscreen mode. False if it is a windowed mode.
*/
bool isFullScreen() const { return (m_SDLFlags & SDL_WINDOW_FULLSCREEN) ? true : false;};
/** True if this mode uses the OpenGL renderer. False otherwise.
*/
bool isOpenGL() const { return (m_SDLFlags & SDL_WINDOW_OPENGL) ? true : false; };
/** Is this screen mode an SDL only screen mode
*/
bool isSDL() const { return (!(m_SDLFlags & SDL_WINDOW_OPENGL)) ? true : false; };
/** Sets the pixel format enum.
*/
void setFormat(uint32_t format) { m_format = format;}
/** Returns the pixel format enum.
*/
uint32_t getFormat() const { return m_format; }
/** Sets the display index.
*/
void setDisplay(uint8_t display) { m_display = display; }
/** Returns the display index.
*/
uint8_t getDisplay() const { return m_display; }
/** Sets the render driver name.
*/
void setRenderDriverName(const std::string driver) { m_renderDriver = driver; }
/** Returns the render driver name. Default is "".
*/
const std::string& getRenderDriverName() const { return m_renderDriver; }
/** Sets the index of the render driver used by SDL.
*/
void setRenderDriverIndex(int8_t index) { m_renderDriverIndex = index; }
/** Returns the index of the render driver. Default is -1.
*/
int8_t getRenderDriverIndex() const { return m_renderDriverIndex; }
//OpenGL, windowed
static const uint32_t WINDOWED_OPENGL = SDL_WINDOW_OPENGL;
//OpenGL, fullscreen
static const uint32_t FULLSCREEN_OPENGL = SDL_WINDOW_OPENGL | SDL_WINDOW_FULLSCREEN;
//SDL, windowed
static const uint32_t WINDOWED_SDL = 0;
//SDL, fullscreen
static const uint32_t FULLSCREEN_SDL = SDL_WINDOW_FULLSCREEN;
private:
uint16_t m_width;
uint16_t m_height;
uint16_t m_bpp;
uint16_t m_refreshRate;
uint32_t m_SDLFlags;
uint32_t m_format;
uint8_t m_display;
std::string m_renderDriver;
int8_t m_renderDriverIndex;
}; //ScreenMode
class DeviceCaps {
public:
/** Constructor.
*/
DeviceCaps();
/** Destructor.
*/
~DeviceCaps();
/** Should be called AFTER SDL_Init() has been called
*/
void fillDeviceCaps();
/** Clears all information gathered for the device
*/
void reset();
/** Gets the available video drivers for your operating system
*/
std::vector<std::string> getAvailableVideoDrivers() const { return m_availableVideoDrivers; };
/** Gets the available render drivers for your operating system
*/
std::vector<std::string> getAvailableRenderDrivers() const { return m_availableRenderDrivers; };
/** Returns a vector containing screen modes.
*/
std::vector<ScreenMode> getSupportedScreenModes() const { return m_screenModes; };
/** Gets the nearest valid screen mode based on the arguments passed
*/
ScreenMode getNearestScreenMode(uint16_t width, uint16_t height, uint16_t bpp, const std::string& renderer, bool fs) const;
/** Gets the nearest valid screen mode based on the arguments passed
*/
ScreenMode getNearestScreenMode(uint16_t width, uint16_t height, uint16_t bpp, const std::string& renderer, bool fs, uint16_t refresh, uint8_t display = 0) const;
/** Returns the name of the current video driver.
*/
std::string getVideoDriverName() const { return m_videoDriverName; }
/** Sets the name of the video driver.
*/
void setVideoDriverName(const std::string& driver) { m_videoDriverName = driver; }
/** Returns the name of the current render driver or
* an empty string to initialize the first one supporting the requested flags.
*/
std::string getRenderDriverName() const { return m_renderDriverName; }
/** Sets the name of the render driver.
*/
void setRenderDriverName(const std::string& driver);
/** Returns the number of displays.
*/
uint8_t getDisplayCount() const;
/** Returns the display name for the given display index.
*/
std::string getDisplayName(uint8_t display = 0) const;
/** Returns the SDL_PixelFormatEnum of the desktop for the given display index.
*/
uint32_t getDesktopFormat(uint8_t display = 0) const;
/** Returns the refresh rate in Hz of the desktop for the given display index.
*/
int32_t getDesktopRefreshRate(uint8_t display = 0) const;
/** Returns the width of the desktop resolution for the given display index.
*/
int32_t getDesktopWidth(uint8_t display = 0) const;
/** Returns the height of the desktop resolution for the given display index.
*/
int32_t getDesktopHeight(uint8_t display = 0) const;
/** Returns the bounding points for the given display index.
*/
Rect getDisplayBounds(uint8_t display = 0) const;
private:
std::vector<ScreenMode> m_screenModes;
std::string m_videoDriverName;
std::vector<std::string> m_availableVideoDrivers;
std::string m_renderDriverName;
int8_t m_renderDriverIndex;
std::vector<std::string> m_availableRenderDrivers;
/** Called in the constructor. No need for anyone to call this
*/
void fillAvailableDrivers();
}; //DeviceCaps
} //FIFE
#endif //FIFE_DEVICECAPS_H
|
