video_driver.hpp

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * 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.
 * 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.
 * 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/>.
 */
 
#ifndef VIDEO_VIDEO_DRIVER_HPP
#define VIDEO_VIDEO_DRIVER_HPP
 
#include "../debug.h"
#include "../driver.h"
#include "../core/geometry_type.hpp"
#include "../core/math_func.hpp"
#include "../gfx_func.h"
#include "../settings_type.h"
#include "../zoom_type.h"
#include "../network/network_func.h"
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <mutex>
#include <thread>
 
extern std::string _ini_videodriver;
extern std::vector<Dimension> _resolutions;
extern Dimension _cur_resolution;
extern bool _rightclick_emulate;
extern bool _video_hw_accel;
extern bool _video_vsync;
 
class VideoDriver : public Driver {
  const uint DEFAULT_WINDOW_WIDTH = 640u;  
  const uint DEFAULT_WINDOW_HEIGHT = 480u; 
 
public:
  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) {}
 
  virtual void MakeDirty(int left, int top, int width, int height) = 0;
 
  virtual void MainLoop() = 0;
 
  virtual bool ChangeResolution(int w, int h) = 0;
 
  virtual bool ToggleFullscreen(bool fullscreen) = 0;
 
  virtual void ToggleVsync([[maybe_unused]] bool vsync) {}
 
  virtual bool AfterBlitterChange()
  {
    return true;
  }
  virtual bool AfterBlitterChange() {…}
 
  virtual bool ClaimMousePointer()
  {
    return true;
  }
 
  virtual bool UseSystemCursor()
  {
    return false;
  }
  virtual bool UseSystemCursor() {…}
 
  virtual void PopulateSystemSprites() {}
 
  virtual void ClearSystemSprites() {}
 
  virtual bool HasGUI() const
  {
    return true;
  }
  virtual bool HasGUI() const {…}
 
  virtual bool HasEfficient8Bpp() const
  {
    return false;
  }
  virtual bool HasEfficient8Bpp() const {…}
 
  virtual bool HasAnimBuffer()
  {
    return false;
  }
  virtual bool HasAnimBuffer() {…}
 
  virtual uint8_t *GetAnimBuffer()
  {
    return nullptr;
  }
  virtual uint8_t *GetAnimBuffer() {…}
 
  virtual void EditBoxLostFocus() {}
 
  virtual void EditBoxGainedFocus() {}
 
  virtual std::vector<int> GetListOfMonitorRefreshRates()
  {
    return {};
  }
  virtual std::vector<int> GetListOfMonitorRefreshRates() {…}
 
  virtual int GetSuggestedUIScale()
  {
    float dpi_scale = this->GetDPIScale();
 
    return Clamp(dpi_scale * 100, MIN_INTERFACE_SCALE, MAX_INTERFACE_SCALE);
  }
  virtual int GetSuggestedUIScale() {…}
 
  virtual std::string_view GetInfoString() const
  {
    return this->GetName();
  }
 
  void QueueOnMainThread(std::function<void()> &&func)
  {
    std::lock_guard<std::mutex> lock(this->cmd_queue_mutex);
 
    this->cmd_queue.emplace_back(std::forward<std::function<void()>>(func));
  }
  void QueueOnMainThread(std::function<void()> &&func) {…}
 
  void GameLoopPause();
 
  static VideoDriver *GetInstance()
  {
    return static_cast<VideoDriver *>(DriverFactoryBase::GetActiveDriver(Driver::DT_VIDEO).get());
  }
  static VideoDriver *GetInstance() {…}
 
  static std::string GetCaption();
 
  struct VideoBufferLocker {
    VideoBufferLocker()
    {
      this->unlock = VideoDriver::GetInstance()->LockVideoBuffer();
    }
 
    ~VideoBufferLocker()
    {
      if (this->unlock) VideoDriver::GetInstance()->UnlockVideoBuffer();
    }
 
  private:
    bool unlock; 
  };
  struct VideoBufferLocker {…};
 
protected:
  const uint ALLOWED_DRIFT = 5; 
 
  virtual Dimension GetScreenSize() const { return { DEFAULT_WINDOW_WIDTH, DEFAULT_WINDOW_HEIGHT }; }
 
  virtual float GetDPIScale() { return 1.0f; }
 
  void UpdateAutoResolution()
  {
    if (_cur_resolution.width == 0 || _cur_resolution.height == 0) {
      /* Auto-detect a good resolution. We aim for 75% of the screen size.
       * Limit width times height times bytes per pixel to fit a 32 bit
       * integer, This way all internal drawing routines work correctly. */
      Dimension res = this->GetScreenSize();
      _cur_resolution.width  = ClampU(res.width  * 3 / 4, DEFAULT_WINDOW_WIDTH, UINT16_MAX / 2);
      _cur_resolution.height = ClampU(res.height * 3 / 4, DEFAULT_WINDOW_HEIGHT, UINT16_MAX / 2);
    }
  }
  void UpdateAutoResolution() {…}
 
  virtual void InputLoop() {}
 
  virtual bool LockVideoBuffer()
  {
    return false;
  }
  virtual bool LockVideoBuffer() {…}
 
  virtual void UnlockVideoBuffer() {}
 
  virtual void Paint() {}
 
  virtual void CheckPaletteAnim() {}
 
  virtual bool PollEvent() { return false; };
 
  void StartGameThread();
 
  void StopGameThread();
 
  void Tick();
 
  void SleepTillNextTick();
 
  std::chrono::steady_clock::duration GetGameInterval()
  {
#ifdef DEBUG_DUMP_COMMANDS
    /* When replaying, run as fast as we can. */
    extern bool _ddc_fastforward;
    if (_ddc_fastforward) return std::chrono::microseconds(0);
#endif /* DEBUG_DUMP_COMMANDS */
 
    TicToc::Tick("GameTick");
 
    /* If we are paused, run on normal speed. */
    if (_pause_mode.Any()) return std::chrono::milliseconds(MILLISECONDS_PER_TICK);
    /* Infinite speed, as quickly as you can. */
    if (_game_speed == 0) return std::chrono::microseconds(0);
 
    return std::chrono::microseconds(MILLISECONDS_PER_TICK * 1000 * 100 / _game_speed);
  }
 
  std::chrono::steady_clock::duration GetDrawInterval()
  {
    TicToc::Tick("DrawTick");
 
    /* If vsync, draw interval is decided by the display driver */
    if (_video_vsync && this->uses_hardware_acceleration) return std::chrono::microseconds(0);
    return std::chrono::microseconds(1000000 / _settings_client.gui.refresh_rate);
  }
 
  void DrainCommandQueue()
  {
    std::vector<std::function<void()>> cmds{};
 
    {
      /* Exchange queue with an empty one to limit the time we
       * hold the mutex. This also ensures that queued functions can
       * add new functions to the queue without everything blocking. */
      std::lock_guard<std::mutex> lock(this->cmd_queue_mutex);
      cmds.swap(this->cmd_queue);
    }
 
    for (auto &f : cmds) {
      f();
    }
  }
  void DrainCommandQueue() {…}
 
  std::chrono::steady_clock::time_point next_game_tick;
  std::chrono::steady_clock::time_point next_draw_tick;
 
  bool fast_forward_key_pressed; 
  bool fast_forward_via_key; 
 
  bool is_game_threaded;
  std::thread game_thread;
  std::mutex game_state_mutex;
  std::mutex game_thread_wait_mutex;
 
  bool uses_hardware_acceleration;
 
  static void GameThreadThunk(VideoDriver *drv);
 
private:
  std::mutex cmd_queue_mutex;
  std::vector<std::function<void()>> cmd_queue;
 
  void GameLoop();
  void GameThread();
};
class VideoDriver : public Driver {…};
 
#endif /* VIDEO_VIDEO_DRIVER_HPP */