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 "../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 <atomic>
#include <chrono>
#include <condition_variable>
#include <mutex>
#include <thread>
#include <vector>
 
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() : fast_forward_key_pressed(false), fast_forward_via_key(false), is_game_threaded(true), change_blitter(nullptr) {}
 
  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(bool vsync) {}
 
  virtual bool AfterBlitterChange()
  {
    return true;
  }
 
  virtual bool ClaimMousePointer()
  {
    return true;
  }
 
  virtual bool UseSystemCursor()
  {
    return false;
  }
 
  virtual void PopulateSystemSprites() {}
 
  virtual void ClearSystemSprites() {}
 
  virtual bool HasGUI() const
  {
    return true;
  }
 
  virtual bool HasEfficient8Bpp() const
  {
    return false;
  }
 
  virtual bool HasAnimBuffer()
  {
    return false;
  }
 
  virtual uint8 *GetAnimBuffer()
  {
    return nullptr;
  }
 
  virtual void EditBoxLostFocus() {}
 
  virtual void EditBoxGainedFocus() {}
 
  virtual std::vector<int> GetListOfMonitorRefreshRates()
  {
    return {};
  }
 
  virtual ZoomLevel GetSuggestedUIZoom()
  {
    float dpi_scale = this->GetDPIScale();
 
    if (dpi_scale >= 3.0f) return ZOOM_LVL_NORMAL;
    if (dpi_scale >= 1.5f) return ZOOM_LVL_OUT_2X;
    return ZOOM_LVL_OUT_4X;
  }
 
  void ChangeBlitter(const char *new_blitter)
  {
    this->change_blitter = new_blitter;
  }
 
  void GameLoopPause();
 
  static VideoDriver *GetInstance() {
    return static_cast<VideoDriver*>(*DriverFactoryBase::GetActiveDriver(Driver::DT_VIDEO));
  }
 
  struct VideoBufferLocker {
    VideoBufferLocker()
    {
      this->unlock = VideoDriver::GetInstance()->LockVideoBuffer();
    }
 
    ~VideoBufferLocker()
    {
      if (this->unlock) VideoDriver::GetInstance()->UnlockVideoBuffer();
    }
 
  private:
    bool unlock; 
  };
 
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);
    }
  }
 
  virtual void InputLoop() {}
 
  virtual bool LockVideoBuffer() {
    return false;
  }
 
  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()
  {
    /* If we are paused, run on normal speed. */
    if (_pause_mode) 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()
  {
    return std::chrono::microseconds(1000000 / _settings_client.gui.refresh_rate);
  }
 
  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;
 
  static void GameThreadThunk(VideoDriver *drv);
 
private:
  void GameLoop();
  void GameThread();
  void RealChangeBlitter(const char *repl_blitter);
 
  const char *change_blitter; 
};
 
#endif /* VIDEO_VIDEO_DRIVER_HPP */