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