src/video/video_driver.hpp

   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
   8 /** @file video_driver.hpp Base of all video drivers. */
   9
  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;
  29 extern Dimension _cur_resolution;
  30 extern bool _rightclick_emulate;
  31 extern bool _video_hw_accel;
  32 extern bool _video_vsync;
  33
  34 /** The base of all video drivers. */
  35 class VideoDriver : public Driver {
  36         const uint DEFAULT_WINDOW_WIDTH = 640u;  ///< Default window width.
  37         const uint DEFAULT_WINDOW_HEIGHT = 480u; ///< Default window height.
  38
  39 public:
  40         VideoDriver() : fast_forward_key_pressed(false), fast_forward_via_key(false), is_game_threaded(true) {}
  41
  42         /**
  43          * Mark a particular area dirty.
  44          * @param left   The left most line of the dirty area.
  45          * @param top    The top most line of the dirty area.
  46          * @param width  The width of the dirty area.
  47          * @param height The height of the dirty area.
  48          */
  49         virtual void MakeDirty(int left, int top, int width, int height) = 0;
  50
  51         /**
  52          * Perform the actual drawing.
  53          */
  54         virtual void MainLoop() = 0;
  55
  56         /**
  57          * Change the resolution of the window.
  58          * @param w The new width.
  59          * @param h The new height.
  60          * @return True if the change succeeded.
  61          */
  62         virtual bool ChangeResolution(int w, int h) = 0;
  63
  64         /**
  65          * Change the full screen setting.
  66          * @param fullscreen The new setting.
  67          * @return True if the change succeeded.
  68          */
  69         virtual bool ToggleFullscreen(bool fullscreen) = 0;
  70
  71         /**
  72          * Change the vsync setting.
  73          * @param vsync The new setting.
  74          */
  75         virtual void ToggleVsync(bool vsync) {}
  76
  77         /**
  78          * Callback invoked after the blitter was changed.
  79          * @return True if no error.
  80          */
  81         virtual bool AfterBlitterChange()
  82         {
  83                 return true;
  84         }
  85
  86         virtual bool ClaimMousePointer()
  87         {
  88                 return true;
  89         }
  90
  91         /**
  92          * Get whether the mouse cursor is drawn by the video driver.
  93          * @return True if cursor drawing is done by the video driver.
  94          */
  95         virtual bool UseSystemCursor()
  96         {
  97                 return false;
  98         }
  99
 100         /**
 101          * Populate all sprites in cache.
 102          */
 103         virtual void PopulateSystemSprites() {}
 104
 105         /**
 106          * Clear all cached sprites.
 107          */
 108         virtual void ClearSystemSprites() {}
 109
 110         /**
 111          * Whether the driver has a graphical user interface with the end user.
 112          * Or in other words, whether we should spawn a thread for world generation
 113          * and NewGRF scanning so the graphical updates can keep coming. Otherwise
 114          * progress has to be shown on the console, which uses by definition another
 115          * thread/process for display purposes.
 116          * @return True for all drivers except null and dedicated.
 117          */
 118         virtual bool HasGUI() const
 119         {
 120                 return true;
 121         }
 122
 123         /**
 124          * Has this video driver an efficient code path for palette animated 8-bpp sprites?
 125          * @return True if the driver has an efficient code path for 8-bpp.
 126          */
 127         virtual bool HasEfficient8Bpp() const
 128         {
 129                 return false;
 130         }
 131
 132         /**
 133          * Does this video driver support a separate animation buffer in addition to the colour buffer?
 134          * @return True if a separate animation buffer is supported.
 135          */
 136         virtual bool HasAnimBuffer()
 137         {
 138                 return false;
 139         }
 140
 141         /**
 142          * Get a pointer to the animation buffer of the video back-end.
 143          * @return Pointer to the buffer or nullptr if no animation buffer is supported.
 144          */
 145         virtual uint8 *GetAnimBuffer()
 146         {
 147                 return nullptr;
 148         }
 149
 150         /**
 151          * An edit box lost the input focus. Abort character compositing if necessary.
 152          */
 153         virtual void EditBoxLostFocus() {}
 154
 155         /**
 156          * An edit box gained the input focus
 157          */
 158         virtual void EditBoxGainedFocus() {}
 159
 160         /**
 161          * Get a list of refresh rates of each available monitor.
 162          * @return A vector of the refresh rates of all available monitors.
 163          */
 164         virtual std::vector<int> GetListOfMonitorRefreshRates()
 165         {
 166                 return {};
 167         }
 168
 169         /**
 170          * Get a suggested default GUI zoom taking screen DPI into account.
 171          */
 172         virtual ZoomLevel GetSuggestedUIZoom()
 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
 181         /**
 182          * Queue a function to be called on the main thread with game state
 183          * lock held and video buffer locked. Queued functions will be
 184          * executed on the next draw tick.
 185          * @param func Function to call.
 186          */
 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
 196         /**
 197          * Get the currently active instance of the video driver.
 198          */
 199         static VideoDriver *GetInstance() {
 200                 return static_cast<VideoDriver*>(*DriverFactoryBase::GetActiveDriver(Driver::DT_VIDEO));
 201         }
 202
 203         /**
 204          * Helper struct to ensure the video buffer is locked and ready for drawing. The destructor
 205          * will make sure the buffer is unlocked no matter how the scope is exited.
 206          */
 207         struct VideoBufferLocker {
 208                 VideoBufferLocker()
 209                 {
 210                         this->unlock = VideoDriver::GetInstance()->LockVideoBuffer();
 211                 }
 212
 213                 ~VideoBufferLocker()
 214                 {
 215                         if (this->unlock) VideoDriver::GetInstance()->UnlockVideoBuffer();
 216                 }
 217
 218         private:
 219                 bool unlock; ///< Stores if the lock did anything that has to be undone.
 220         };
 221
 222 protected:
 223         const uint ALLOWED_DRIFT = 5; ///< How many times videodriver can miss deadlines without it being overly compensated.
 224
 225         /**
 226          * Get the resolution of the main screen.
 227          */
 228         virtual Dimension GetScreenSize() const { return { DEFAULT_WINDOW_WIDTH, DEFAULT_WINDOW_HEIGHT }; }
 229
 230         /**
 231          * Get DPI scaling factor of the screen OTTD is displayed on.
 232          * @return 1.0 for default platform DPI, > 1.0 for higher DPI values, and < 1.0 for smaller DPI values.
 233          */
 234         virtual float GetDPIScale() { return 1.0f; }
 235
 236         /**
 237          * Apply resolution auto-detection and clamp to sensible defaults.
 238          */
 239         void UpdateAutoResolution()
 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
 251         /**
 252          * Handle input logic, is CTRL pressed, should we fast-forward, etc.
 253          */
 254         virtual void InputLoop() {}
 255
 256         /**
 257          * Make sure the video buffer is ready for drawing.
 258          * @returns True if the video buffer has to be unlocked.
 259          */
 260         virtual bool LockVideoBuffer() {
 261                 return false;
 262         }
 263
 264         /**
 265          * Unlock a previously locked video buffer.
 266          */
 267         virtual void UnlockVideoBuffer() {}
 268
 269         /**
 270          * Paint the window.
 271          */
 272         virtual void Paint() {}
 273
 274         /**
 275          * Process any pending palette animation.
 276          */
 277         virtual void CheckPaletteAnim() {}
 278
 279         /**
 280          * Process a single system event.
 281          * @returns False if there are no more events to process.
 282          */
 283         virtual bool PollEvent() { return false; };
 284
 285         /**
 286          * Start the loop for game-tick.
 287          */
 288         void StartGameThread();
 289
 290         /**
 291          * Stop the loop for the game-tick. This can still tick at most one time before truly shutting down.
 292          */
 293         void StopGameThread();
 294
 295         /**
 296          * Give the video-driver a tick.
 297          * It will process any potential game-tick and/or draw-tick, and/or any
 298          * other video-driver related event.
 299          */
 300         void Tick();
 301
 302         /**
 303          * Sleep till the next tick is about to happen.
 304          */
 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         /** Execute all queued commands. */
 323         void DrainCommandQueue()
 324         {
 325                 std::vector<std::function<void()>> cmds{};
 326
 327                 {
 328                         /* Exchange queue with an empty one to limit the time we
 329                          * hold the mutex. This also ensures that queued functions can
 330                          * add new functions to the queue without everything blocking. */
 331                         std::lock_guard<std::mutex> lock(this->cmd_queue_mutex);
 332                         cmds.swap(this->cmd_queue);
 333                 }
 334
 335                 for (auto &f : cmds) {
 336                         f();
 337                 }
 338         }
 339
 340         std::chrono::steady_clock::time_point next_game_tick;
 341         std::chrono::steady_clock::time_point next_draw_tick;
 342
 343         bool fast_forward_key_pressed; ///< The fast-forward key is being pressed.
 344         bool fast_forward_via_key; ///< The fast-forward was enabled by key press.
 345
 346         bool is_game_threaded;
 347         std::thread game_thread;
 348         std::mutex game_state_mutex;
 349         std::mutex game_thread_wait_mutex;
 350
 351         static void GameThreadThunk(VideoDriver *drv);
 352
 353 private:
 354         std::mutex cmd_queue_mutex;
 355         std::vector<std::function<void()>> cmd_queue;
 356
 357         void GameLoop();
 358         void GameThread();
 359 };
 360
 361 #endif /* VIDEO_VIDEO_DRIVER_HPP */