FIFE  6e1afdbeda11afe9ac53e6023a4be96ef88f1dc6
enginesettings.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  * Copyright (C) 2005-2017 by the FIFE team *
3  * http://www.fifengine.net *
4  * This file is part of FIFE. *
5  * *
6  * FIFE is free software; you can redistribute it and/or *
7  * modify it under the terms of the GNU Lesser General Public *
8  * License as published by the Free Software Foundation; either *
9  * version 2.1 of the License, or (at your option) any later version. *
10  * *
11  * This library is distributed in the hope that it will be useful, *
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of *
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
14  * Lesser General Public License for more details. *
15  * *
16  * You should have received a copy of the GNU Lesser General Public *
17  * License along with this library; if not, write to the *
18  * Free Software Foundation, Inc., *
19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA *
20  ***************************************************************************/
21 
22 // Standard C++ library includes
23 #include <algorithm>
24 #include <string>
25 
26 // 3rd party library includes
27 #include <SDL.h>
28 
29 // FIFE includes
30 // These includes are split up in two parts, separated by one empty line
31 // First block: files included from the FIFE root src directory
32 // Second block: files included from the same folder
33 #include "util/base/exception.h"
34 #include "util/log/logger.h"
35 
36 #include "enginesettings.h"
37 
38 namespace FIFE {
42  static Logger _log(LM_CONTROLLER);
43 
44  const float MAXIMUM_VOLUME = 10.0;
45 
47  m_bitsperpixel(0),
48  m_fullscreen(false),
49  m_refreshRate(60),
50  m_displayIndex(0),
51  m_vSync(false),
52  m_renderDriver(""),
53  m_initialvolume(MAXIMUM_VOLUME / 2),
54  m_renderbackend("SDL"),
55  m_sdlremovefakealpha(false),
56  m_oglcompressimages(false),
57  m_ogluseframebuffer(true),
58  m_oglusenpot(true),
59  m_oglMipmapping(false),
60  m_oglMonochrome(false),
61  m_oglTextureFilter(TEXTURE_FILTER_NONE),
62  m_oglDepthBuffer(false),
63  m_alphaTestValue(0.3),
64  m_screenwidth(800),
65  m_screenheight(600),
66  m_windowtitle("FIFE"),
67  m_windowicon(""),
68  m_defaultfontpath("fonts/FreeSans.ttf"),
69  m_defaultfontsize(8),
70  m_defaultfontglyphs("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.,!?-+/():;%&amp;`'*#=[]\\\""),
71  m_iscolorkeyenabled(false),
72  m_lighting(0),
73  m_isframelimit(false),
74  m_framelimit(60),
75  m_mousesensitivity(0.0),
76  m_mouseacceleration(false),
77  m_nativeimagecursor(false),
78  m_joystickSupport(false) {
79  m_colorkey.r = 255;
80  m_colorkey.g = 0;
81  m_colorkey.b = 255;
82 
83 #if defined( __unix__ )
84  m_videodriver = "x11";
85 #elif defined( WIN32 )
86  m_videodriver = "windib";
87 #elif defined( __APPLE_CC__ )
88  m_videodriver = "x11";
89 #else
90  m_videodriver = "";
91 #endif
92 
93  }
94 
96  }
97 
99  std::vector<uint8_t> pv = getPossibleBitsPerPixel();
100  std::vector<uint8_t>::iterator i = std::find(pv.begin(), pv.end(), bitsperpixel);
101  if (i != pv.end()) {
102  m_bitsperpixel = bitsperpixel;
103  return;
104  }
105 
106  FL_WARN(_log, LMsg("EngineSettings::setBitsPerPixel() - ")
107  << " Tried to set screen bpp to an unsupporded value of " << bitsperpixel <<
108  ". Setting bpp to use the default value of 0 (the current screen bpp)");
109 
110  m_bitsperpixel = 0; //default value
111  }
112 
113  std::vector<uint8_t> EngineSettings::getPossibleBitsPerPixel() const {
114  std::vector<uint8_t> tmp;
115  tmp.push_back(0);
116  tmp.push_back(16);
117  tmp.push_back(24);
118  tmp.push_back(32);
119  return tmp;
120  }
121 
122  void EngineSettings::setInitialVolume(float volume) {
123  if (volume > getMaxVolume() || volume < 0) {
124  FL_WARN(_log, LMsg("EngineSettings::setInitialVolume() - ")
125  << " Tried to set initial volume to an unsupporded value of " << volume <<
126  ". Setting volume to the default value of 5 (minumum is 0, maximum is 10)");
127 
128  m_initialvolume = 5.0;
129  return;
130  }
131 
132  m_initialvolume = volume;
133  }
134 
136  return MAXIMUM_VOLUME;
137  }
138 
139  void EngineSettings::setRenderBackend(const std::string& renderbackend) {
140  std::vector<std::string> pv = getPossibleRenderBackends();
141  std::vector<std::string>::iterator i = std::find(pv.begin(), pv.end(), renderbackend);
142  if (i != pv.end()) {
143  m_renderbackend = renderbackend;
144  return;
145  }
146  FL_WARN(_log, LMsg("EngineSettings::setRenderBackend() - ")
147  << renderbackend << " is not a valid render backend " <<
148  ". Setting the render backend to the default value of \"SDL\".");
149 
150  m_renderbackend = "SDL";
151  }
152 
153  std::vector<std::string> EngineSettings::getPossibleRenderBackends() {
154  std::vector<std::string> tmp;
155  tmp.push_back("SDL");
156  tmp.push_back("OpenGL");
157  return tmp;
158  }
159 
160  void EngineSettings::setSDLRemoveFakeAlpha(bool sdlremovefakealpha) {
161  m_sdlremovefakealpha = sdlremovefakealpha;
162  }
163 
164  void EngineSettings::setGLCompressImages(bool oglcompressimages) {
165  m_oglcompressimages = oglcompressimages;
166  }
167 
168  void EngineSettings::setGLUseFramebuffer(bool ogluseframebuffer) {
169  m_ogluseframebuffer = ogluseframebuffer;
170  }
171 
172  void EngineSettings::setGLUseNPOT(bool oglusenpot) {
173  m_oglusenpot = oglusenpot;
174  }
175 
177  m_oglTextureFilter = filter;
178  }
179 
181  return m_oglTextureFilter;
182  }
183 
184  void EngineSettings::setGLUseMipmapping(bool mipmapping) {
185  m_oglMipmapping = mipmapping;
186  }
187 
189  return m_oglMipmapping;
190  }
191 
192  void EngineSettings::setGLUseMonochrome(bool monochrome) {
193  m_oglMonochrome = monochrome;
194  }
195 
197  return m_oglMonochrome;
198  }
199 
201  m_oglDepthBuffer = buffer;
202  }
203 
205  return m_oglDepthBuffer;
206  }
207 
209  m_alphaTestValue = alpha;
210  }
211 
213  return m_alphaTestValue;
214  }
215 
217  m_screenwidth = screenwidth;
218  }
219 
221  m_screenheight = screenheight;
222  }
223 
224  void EngineSettings::setDefaultFontPath(const std::string& defaultfontpath) {
225  m_defaultfontpath = defaultfontpath;
226  }
227 
229  m_defaultfontsize = defaultfontsize;
230  }
231 
232  void EngineSettings::setDefaultFontGlyphs(const std::string& defaultfontglyphs) {
233  m_defaultfontglyphs = defaultfontglyphs;
234  }
235 
236  void EngineSettings::setWindowTitle(const std::string& title) {
237  m_windowtitle = title;
238  }
239 
240  void EngineSettings::setWindowIcon(const std::string& icon) {
241  m_windowicon = icon;
242  }
243 
244  void EngineSettings::setColorKeyEnabled(bool colorkeyenable) {
245  m_iscolorkeyenabled = colorkeyenable;
246  }
247 
249  return m_iscolorkeyenabled;
250  }
251 
253  m_colorkey.r = r;
254  m_colorkey.g = g;
255  m_colorkey.b = b;
256  }
257 
258  const SDL_Color& EngineSettings::getColorKey() const {
259  return m_colorkey;
260  }
261 
262  void EngineSettings::setVideoDriver(const std::string& driver) {
263  //TODO: validate the video driver
264  m_videodriver = driver;
265  }
266 
267  const std::string& EngineSettings::getVideoDriver() const {
268  return m_videodriver;
269  }
271  if (lighting <= 2) {
272  m_lighting = lighting;
273  return;
274  }
275 
276  FL_WARN(_log, LMsg("EngineSettings::setLightingModel() - ")
277  << lighting << " is not a valid lighting model." <<
278  ". Setting the lighting model to the default value of 0 (off)");
279 
280  m_lighting = 0;
281  }
282 
284  m_isframelimit = limited;
285  }
286 
288  return m_isframelimit;
289  }
290 
292  m_framelimit = framelimit;
293  }
294 
296  return m_framelimit;
297  }
298 
300  m_mousesensitivity = sens;
301  }
302 
304  return m_mousesensitivity;
305  }
306 
308  m_mouseacceleration = acceleration;
309  }
310 
312  return m_mouseacceleration;
313  }
314 
315  void EngineSettings::setNativeImageCursorEnabled(bool nativeimagecursor) {
316  m_nativeimagecursor = nativeimagecursor;
317  }
318 
320  return m_nativeimagecursor;
321  }
322 
324  m_joystickSupport = support;
325  }
326 
328  return m_joystickSupport;
329  }
330 }
331 
#define FL_WARN(logger, msg)
Definition: logger.h:72
bool isGLUseMonochrome() const
Tells if OpenGL renderbackend should render only monochrome.
void setDefaultFontSize(uint16_t defaultfontsize)
Sets size for default font.
float getMaxVolume() const
Gets maximum volume that can be set.
bool isColorKeyEnabled() const
Gets whether the colorkey feature is in use.
const float MAXIMUM_VOLUME
~EngineSettings()
Destructor.
Helper class to create log strings out from separate parts Usage: LMsg("some text") << variable << "...
Definition: logger.h:82
void setGLUseFramebuffer(bool ogluseframebuffer)
Sets if OpenGL renderbackend should use FramebufferObject (when available)
void setFrameLimitEnabled(bool limited)
Sets whether to use the frame limiter.
void setInitialVolume(float volume)
Sets initial engine sound volume.
void setSDLRemoveFakeAlpha(bool sdlremovefakealpha)
Sets if fake alpha is removed in SDL renderbackend.
void setDefaultFontGlyphs(const std::string &defaultfontglyphs)
Sets glyphs for default font.
TextureFiltering m_oglTextureFilter
EngineSettings()
Constructor.
void setMouseSensitivity(float sens)
Sets mouse sensitivity.
static Logger _log(LM_AUDIO)
bool isFrameLimitEnabled() const
Gets whether the frame limiter is in use.
void setGLUseMonochrome(bool monochrome)
Sets if OpenGL renderbackend should render only monochrome.
void setGLTextureFiltering(TextureFiltering filter)
Sets texture filtering method for OpenGL renderbackend.
std::string m_defaultfontglyphs
void setColorKeyEnabled(bool colorkeyenable)
Sets whether to use the colorkey feature.
const SDL_Color & getColorKey() const
Gets the global colorkey setting.
const std::string & getVideoDriver() const
Gets the video driver.
void setGLCompressImages(bool oglcompressimages)
Sets if images are compress by video driver in OpenGL renderbackend.
void setNativeImageCursorEnabled(bool nativeimagecursor)
Enables or disables native image cursor.
void setWindowTitle(const std::string &title)
Sets the title of the window.
unsigned char uint8_t
Definition: core.h:38
float getMouseSensitivity() const
Gets mouse sensitivity.
bool isGLUseMipmapping() const
Tells if OpenGL renderbackend should use mipmapping.
void setDefaultFontPath(const std::string &defaultfontpath)
Sets path for default font.
void setGLUseDepthBuffer(bool buffer)
Sets if OpenGL renderbackend should use depth buffer.
void setGLUseMipmapping(bool mipmapping)
Sets if OpenGL renderbackend should use mipmapping.
TextureFiltering getGLTextureFiltering() const
Gets current texture filter which uses OpenGL.
std::string m_defaultfontpath
void setScreenHeight(uint16_t screenheight)
Sets screen height (pixels)
void setFrameLimit(uint16_t framelimit)
Sets the frame limit.
void setGLAlphaTestValue(float alpha)
Sets alpha test value for OpenGL renderbackend.
void setRenderBackend(const std::string &renderbackend)
Sets name for renderbackend.
unsigned short uint16_t
Definition: core.h:39
void setJoystickSupport(bool support)
Enables or disables joystick and gamepad support.
void setScreenWidth(uint16_t screenwidth)
Sets screen width (pixels)
void setColorKey(uint8_t r, uint8_t g, uint8_t b)
Sets the global colorkey to use for images.
std::vector< uint8_t > getPossibleBitsPerPixel() const
Gets all possible bits per pixel values.
bool isMouseAccelerationEnabled() const
Returns if mouse acceleration is enabled or not.
std::string m_windowtitle
uint16_t getFrameLimit() const
Gets the frame limit.
float getGLAlphaTestValue() const
Gets current alpha test value which uses OpenGL.
std::string m_windowicon
bool isJoystickSupport() const
Returns whether joystick and gamepad support is enabled or not.
void setGLUseNPOT(bool oglusenpot)
Sets if OpenGL renderbackend should use NPOT Textures (when available)
bool isNativeImageCursorEnabled() const
Returns whether cursors set to an image or an animation are drawn natively.
void setBitsPerPixel(uint8_t bitsperpixel)
Sets bits per pixel.
TextureFiltering
Definition: renderbackend.h:99
void setMouseAccelerationEnabled(bool acceleration)
Sets mouse acceleration if mouse acceleration is enabled, then the mouse sensitivity is used as speed...
void setLightingModel(uint32_t lighting)
Sets the light model.
void setWindowIcon(const std::string &icon)
Sets the icon that appears in the window title bar.
void setVideoDriver(const std::string &driver)
Sets the video driver.
std::string m_videodriver
unsigned int uint32_t
Definition: core.h:40
bool isGLUseDepthBuffer() const
Tells if OpenGL renderbackend should use depth buffer.
std::string m_renderbackend
std::vector< std::string > getPossibleRenderBackends()
Gets all possible renderbackend names.