OpenTTD Source  1.11.2
video_driver.hpp
Go to the documentation of this file.
1 /*
2  * This file is part of OpenTTD.
3  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
4  * OpenTTD 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.
5  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
6  */
7 
10 #ifndef VIDEO_VIDEO_DRIVER_HPP
11 #define VIDEO_VIDEO_DRIVER_HPP
12 
13 #include "../driver.h"
14 #include "../core/geometry_type.hpp"
15 #include "../core/math_func.hpp"
16 #include "../gfx_func.h"
17 #include "../settings_type.h"
18 #include "../zoom_type.h"
19 #include <atomic>
20 #include <chrono>
21 #include <condition_variable>
22 #include <mutex>
23 #include <thread>
24 #include <vector>
25 #include <functional>
26 
27 extern std::string _ini_videodriver;
28 extern std::vector<Dimension> _resolutions;
30 extern bool _rightclick_emulate;
31 extern bool _video_hw_accel;
32 extern bool _video_vsync;
33 
35 class VideoDriver : public Driver {
36  const uint DEFAULT_WINDOW_WIDTH = 640u;
37  const uint DEFAULT_WINDOW_HEIGHT = 480u;
38 
39 public:
40  VideoDriver() : fast_forward_key_pressed(false), fast_forward_via_key(false), is_game_threaded(true) {}
41 
49  virtual void MakeDirty(int left, int top, int width, int height) = 0;
50 
54  virtual void MainLoop() = 0;
55 
62  virtual bool ChangeResolution(int w, int h) = 0;
63 
69  virtual bool ToggleFullscreen(bool fullscreen) = 0;
70 
75  virtual void ToggleVsync(bool vsync) {}
76 
81  virtual bool AfterBlitterChange()
82  {
83  return true;
84  }
85 
86  virtual bool ClaimMousePointer()
87  {
88  return true;
89  }
90 
95  virtual bool UseSystemCursor()
96  {
97  return false;
98  }
99 
103  virtual void PopulateSystemSprites() {}
104 
108  virtual void ClearSystemSprites() {}
109 
118  virtual bool HasGUI() const
119  {
120  return true;
121  }
122 
127  virtual bool HasEfficient8Bpp() const
128  {
129  return false;
130  }
131 
136  virtual bool HasAnimBuffer()
137  {
138  return false;
139  }
140 
145  virtual uint8 *GetAnimBuffer()
146  {
147  return nullptr;
148  }
149 
153  virtual void EditBoxLostFocus() {}
154 
158  virtual void EditBoxGainedFocus() {}
159 
164  virtual std::vector<int> GetListOfMonitorRefreshRates()
165  {
166  return {};
167  }
168 
173  {
174  float dpi_scale = this->GetDPIScale();
175 
176  if (dpi_scale >= 3.0f) return ZOOM_LVL_NORMAL;
177  if (dpi_scale >= 1.5f) return ZOOM_LVL_OUT_2X;
178  return ZOOM_LVL_OUT_4X;
179  }
180 
187  void QueueOnMainThread(std::function<void()> &&func)
188  {
189  std::lock_guard<std::mutex> lock(this->cmd_queue_mutex);
190 
191  this->cmd_queue.emplace_back(std::forward<std::function<void()>>(func));
192  }
193 
194  void GameLoopPause();
195 
201  }
202 
209  {
211  }
212 
214  {
216  }
217 
218  private:
219  bool unlock;
220  };
221 
222 protected:
223  const uint ALLOWED_DRIFT = 5;
224 
229 
234  virtual float GetDPIScale() { return 1.0f; }
235 
240  {
241  if (_cur_resolution.width == 0 || _cur_resolution.height == 0) {
242  /* Auto-detect a good resolution. We aim for 75% of the screen size.
243  * Limit width times height times bytes per pixel to fit a 32 bit
244  * integer, This way all internal drawing routines work correctly. */
245  Dimension res = this->GetScreenSize();
246  _cur_resolution.width = ClampU(res.width * 3 / 4, DEFAULT_WINDOW_WIDTH, UINT16_MAX / 2);
247  _cur_resolution.height = ClampU(res.height * 3 / 4, DEFAULT_WINDOW_HEIGHT, UINT16_MAX / 2);
248  }
249  }
250 
254  virtual void InputLoop() {}
255 
260  virtual bool LockVideoBuffer() {
261  return false;
262  }
263 
267  virtual void UnlockVideoBuffer() {}
268 
272  virtual void Paint() {}
273 
277  virtual void CheckPaletteAnim() {}
278 
283  virtual bool PollEvent() { return false; };
284 
288  void StartGameThread();
289 
293  void StopGameThread();
294 
300  void Tick();
301 
305  void SleepTillNextTick();
306 
307  std::chrono::steady_clock::duration GetGameInterval()
308  {
309  /* If we are paused, run on normal speed. */
310  if (_pause_mode) return std::chrono::milliseconds(MILLISECONDS_PER_TICK);
311  /* Infinite speed, as quickly as you can. */
312  if (_game_speed == 0) return std::chrono::microseconds(0);
313 
314  return std::chrono::microseconds(MILLISECONDS_PER_TICK * 1000 * 100 / _game_speed);
315  }
316 
317  std::chrono::steady_clock::duration GetDrawInterval()
318  {
319  return std::chrono::microseconds(1000000 / _settings_client.gui.refresh_rate);
320  }
321 
322  std::chrono::steady_clock::time_point next_game_tick;
323  std::chrono::steady_clock::time_point next_draw_tick;
324 
327 
328  bool is_game_threaded;
329  std::thread game_thread;
330  std::mutex game_state_mutex;
331  std::mutex game_thread_wait_mutex;
332 
333  static void GameThreadThunk(VideoDriver *drv);
334 
335 private:
336  std::mutex cmd_queue_mutex;
337  std::vector<std::function<void()>> cmd_queue;
338 
341  {
342  std::vector<std::function<void()>> cmds{};
343 
344  {
345  /* Exchange queue with an empty one to limit the time we
346  * hold the mutex. This also ensures that queued functions can
347  * add new functions to the queue without everything blocking. */
348  std::lock_guard<std::mutex> lock(this->cmd_queue_mutex);
349  cmds.swap(this->cmd_queue);
350  }
351 
352  for (auto &f : cmds) {
353  f();
354  }
355  }
356 
357  void GameLoop();
358  void GameThread();
359 };
360 
361 #endif /* VIDEO_VIDEO_DRIVER_HPP */
VideoDriver::Tick
void Tick()
Give the video-driver a tick.
Definition: video_driver.cpp:100
GUISettings::refresh_rate
uint16 refresh_rate
How often we refresh the screen (time between draw-ticks).
Definition: settings_type.h:160
VideoDriver::HasAnimBuffer
virtual bool HasAnimBuffer()
Does this video driver support a separate animation buffer in addition to the colour buffer?
Definition: video_driver.hpp:136
ZOOM_LVL_OUT_2X
@ ZOOM_LVL_OUT_2X
Zoomed 2 times out.
Definition: zoom_type.h:25
DriverFactoryBase::GetActiveDriver
static Driver ** GetActiveDriver(Driver::Type type)
Get the active driver for the given type.
Definition: driver.h:86
VideoDriver
The base of all video drivers.
Definition: video_driver.hpp:35
Dimension
Dimensions (a width and height) of a rectangle in 2D.
Definition: geometry_type.hpp:27
lock
std::mutex lock
synchronization for playback status fields
Definition: win32_m.cpp:34
VideoDriver::CheckPaletteAnim
virtual void CheckPaletteAnim()
Process any pending palette animation.
Definition: video_driver.hpp:277
VideoDriver::MakeDirty
virtual void MakeDirty(int left, int top, int width, int height)=0
Mark a particular area dirty.
VideoDriver::ToggleFullscreen
virtual bool ToggleFullscreen(bool fullscreen)=0
Change the full screen setting.
_cur_resolution
Dimension _cur_resolution
The current resolution.
Definition: driver.cpp:25
ClampU
static uint ClampU(const uint a, const uint min, const uint max)
Clamp an unsigned integer between an interval.
Definition: math_func.hpp:122
ZoomLevel
ZoomLevel
All zoom levels we know.
Definition: zoom_type.h:21
_settings_client
ClientSettings _settings_client
The current settings for this game.
Definition: settings.cpp:79
VideoDriver::HasGUI
virtual bool HasGUI() const
Whether the driver has a graphical user interface with the end user.
Definition: video_driver.hpp:118
VideoDriver::StartGameThread
void StartGameThread()
Start the loop for game-tick.
Definition: video_driver.cpp:84
VideoDriver::GetSuggestedUIZoom
virtual ZoomLevel GetSuggestedUIZoom()
Get a suggested default GUI zoom taking screen DPI into account.
Definition: video_driver.hpp:172
VideoDriver::ClearSystemSprites
virtual void ClearSystemSprites()
Clear all cached sprites.
Definition: video_driver.hpp:108
_video_vsync
bool _video_vsync
Whether we should use vsync (only if _video_hw_accel is enabled).
Definition: video_driver.cpp:24
VideoDriver::GetDPIScale
virtual float GetDPIScale()
Get DPI scaling factor of the screen OTTD is displayed on.
Definition: video_driver.hpp:234
VideoDriver::DEFAULT_WINDOW_HEIGHT
const uint DEFAULT_WINDOW_HEIGHT
Default window height.
Definition: video_driver.hpp:37
VideoDriver::InputLoop
virtual void InputLoop()
Handle input logic, is CTRL pressed, should we fast-forward, etc.
Definition: video_driver.hpp:254
VideoDriver::GetListOfMonitorRefreshRates
virtual std::vector< int > GetListOfMonitorRefreshRates()
Get a list of refresh rates of each available monitor.
Definition: video_driver.hpp:164
VideoDriver::Paint
virtual void Paint()
Paint the window.
Definition: video_driver.hpp:272
_rightclick_emulate
bool _rightclick_emulate
Whether right clicking is emulated.
Definition: driver.cpp:26
VideoDriver::ALLOWED_DRIFT
const uint ALLOWED_DRIFT
How many times videodriver can miss deadlines without it being overly compensated.
Definition: video_driver.hpp:223
VideoDriver::ToggleVsync
virtual void ToggleVsync(bool vsync)
Change the vsync setting.
Definition: video_driver.hpp:75
_pause_mode
PauseMode _pause_mode
The current pause mode.
Definition: gfx.cpp:47
VideoDriver::ChangeResolution
virtual bool ChangeResolution(int w, int h)=0
Change the resolution of the window.
VideoDriver::QueueOnMainThread
void QueueOnMainThread(std::function< void()> &&func)
Queue a function to be called on the main thread with game state lock held and video buffer locked.
Definition: video_driver.hpp:187
VideoDriver::GetInstance
static VideoDriver * GetInstance()
Get the currently active instance of the video driver.
Definition: video_driver.hpp:199
VideoDriver::UnlockVideoBuffer
virtual void UnlockVideoBuffer()
Unlock a previously locked video buffer.
Definition: video_driver.hpp:267
VideoDriver::GetAnimBuffer
virtual uint8 * GetAnimBuffer()
Get a pointer to the animation buffer of the video back-end.
Definition: video_driver.hpp:145
VideoDriver::UseSystemCursor
virtual bool UseSystemCursor()
Get whether the mouse cursor is drawn by the video driver.
Definition: video_driver.hpp:95
VideoDriver::GameLoopPause
void GameLoopPause()
Pause the game-loop for a bit, releasing the game-state lock.
Definition: video_driver.cpp:64
VideoDriver::StopGameThread
void StopGameThread()
Stop the loop for the game-tick.
Definition: video_driver.cpp:93
VideoDriver::PopulateSystemSprites
virtual void PopulateSystemSprites()
Populate all sprites in cache.
Definition: video_driver.hpp:103
VideoDriver::UpdateAutoResolution
void UpdateAutoResolution()
Apply resolution auto-detection and clamp to sensible defaults.
Definition: video_driver.hpp:239
Driver::DT_VIDEO
@ DT_VIDEO
A video driver.
Definition: driver.h:44
VideoDriver::VideoBufferLocker::unlock
bool unlock
Stores if the lock did anything that has to be undone.
Definition: video_driver.hpp:219
VideoDriver::DrainCommandQueue
void DrainCommandQueue()
Execute all queued commands.
Definition: video_driver.hpp:340
_ini_videodriver
std::string _ini_videodriver
The video driver a stored in the configuration file.
Definition: driver.cpp:23
VideoDriver::fast_forward_via_key
bool fast_forward_via_key
The fast-forward was enabled by key press.
Definition: video_driver.hpp:326
_video_hw_accel
bool _video_hw_accel
Whether to consider hardware accelerated video drivers.
Definition: video_driver.cpp:23
MILLISECONDS_PER_TICK
static const uint MILLISECONDS_PER_TICK
The number of milliseconds per game tick.
Definition: gfx_type.h:310
VideoDriver::SleepTillNextTick
void SleepTillNextTick()
Sleep till the next tick is about to happen.
Definition: video_driver.cpp:162
VideoDriver::MainLoop
virtual void MainLoop()=0
Perform the actual drawing.
VideoDriver::fast_forward_key_pressed
bool fast_forward_key_pressed
The fast-forward key is being pressed.
Definition: video_driver.hpp:325
VideoDriver::HasEfficient8Bpp
virtual bool HasEfficient8Bpp() const
Has this video driver an efficient code path for palette animated 8-bpp sprites?
Definition: video_driver.hpp:127
VideoDriver::LockVideoBuffer
virtual bool LockVideoBuffer()
Make sure the video buffer is ready for drawing.
Definition: video_driver.hpp:260
ZOOM_LVL_NORMAL
@ ZOOM_LVL_NORMAL
The normal zoom level.
Definition: zoom_type.h:24
VideoDriver::EditBoxLostFocus
virtual void EditBoxLostFocus()
An edit box lost the input focus.
Definition: video_driver.hpp:153
VideoDriver::DEFAULT_WINDOW_WIDTH
const uint DEFAULT_WINDOW_WIDTH
Default window width.
Definition: video_driver.hpp:36
Driver
A driver for communicating with the user.
Definition: driver.h:23
ZOOM_LVL_OUT_4X
@ ZOOM_LVL_OUT_4X
Zoomed 4 times out.
Definition: zoom_type.h:26
_resolutions
std::vector< Dimension > _resolutions
List of resolutions.
Definition: driver.cpp:24
VideoDriver::PollEvent
virtual bool PollEvent()
Process a single system event.
Definition: video_driver.hpp:283
VideoDriver::VideoBufferLocker
Helper struct to ensure the video buffer is locked and ready for drawing.
Definition: video_driver.hpp:207
_game_speed
uint16 _game_speed
Current game-speed; 100 is 1x, 0 is infinite.
Definition: gfx.cpp:37
ClientSettings::gui
GUISettings gui
settings related to the GUI
Definition: settings_type.h:581
VideoDriver::GetScreenSize
virtual Dimension GetScreenSize() const
Get the resolution of the main screen.
Definition: video_driver.hpp:228
VideoDriver::EditBoxGainedFocus
virtual void EditBoxGainedFocus()
An edit box gained the input focus.
Definition: video_driver.hpp:158
VideoDriver::AfterBlitterChange
virtual bool AfterBlitterChange()
Callback invoked after the blitter was changed.
Definition: video_driver.hpp:81