video_driver.cpp

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/>.
 */
 
#include "../stdafx.h"
#include "../core/random_func.hpp"
#include "../network/network.h"
#include "../blitter/factory.hpp"
#include "../debug.h"
#include "../driver.h"
#include "../fontcache.h"
#include "../gfx_func.h"
#include "../gfxinit.h"
#include "../progress.h"
#include "../rev.h"
#include "../thread.h"
#include "../window_func.h"
#include "video_driver.hpp"
 
#include "../safeguards.h"
 
bool _video_hw_accel; 
bool _video_vsync; 
 
void VideoDriver::GameLoop()
{
  this->next_game_tick += this->GetGameInterval();
 
  /* Avoid next_game_tick getting behind more and more if it cannot keep up. */
  auto now = std::chrono::steady_clock::now();
  if (this->next_game_tick < now - ALLOWED_DRIFT * this->GetGameInterval()) this->next_game_tick = now;
 
  {
    std::lock_guard<std::mutex> lock(this->game_state_mutex);
 
    ::GameLoop();
  }
}
 
void VideoDriver::GameThread()
{
  while (!_exit_game) {
    this->GameLoop();
 
    auto now = std::chrono::steady_clock::now();
    if (this->next_game_tick > now) {
      std::this_thread::sleep_for(this->next_game_tick - now);
    } else {
      /* Ensure we yield this thread if drawings wants to take a lock on
       * the game state. This is mainly because most OSes have an
       * optimization that if you unlock/lock a mutex in the same thread
       * quickly, it will never context switch even if there is another
       * thread waiting to take the lock on the same mutex. */
      std::lock_guard<std::mutex> lock(this->game_thread_wait_mutex);
    }
  }
}
 
void VideoDriver::GameLoopPause()
{
  /* If we are not called from the game-thread, ignore this request. */
  if (std::this_thread::get_id() != this->game_thread.get_id()) return;
 
  this->game_state_mutex.unlock();
 
  {
    /* See GameThread() for more details on this lock. */
    std::lock_guard<std::mutex> lock(this->game_thread_wait_mutex);
  }
 
  this->game_state_mutex.lock();
}
void VideoDriver::GameLoopPause() {…}
 
/* static */ void VideoDriver::GameThreadThunk(VideoDriver *drv)
{
  drv->GameThread();
}
 
void VideoDriver::StartGameThread()
{
  if (this->is_game_threaded) {
    this->is_game_threaded = StartNewThread(&this->game_thread, "ottd:game", &VideoDriver::GameThreadThunk, this);
  }
 
  Debug(driver, 1, "using {}thread for game-loop", this->is_game_threaded ? "" : "no ");
}
void VideoDriver::StartGameThread() {…}
 
void VideoDriver::StopGameThread()
{
  if (!this->is_game_threaded) return;
 
  this->game_thread.join();
}
void VideoDriver::StopGameThread() {…}
 
void VideoDriver::Tick()
{
  if (!this->is_game_threaded && std::chrono::steady_clock::now() >= this->next_game_tick) {
    this->GameLoop();
 
    /* For things like dedicated server, don't run a separate draw-tick. */
    if (!this->HasGUI()) {
      ::InputLoop();
      ::UpdateWindows();
      this->next_draw_tick = this->next_game_tick;
    }
  }
 
  auto now = std::chrono::steady_clock::now();
  if (this->HasGUI() && now >= this->next_draw_tick) {
    this->next_draw_tick += this->GetDrawInterval();
    /* Avoid next_draw_tick getting behind more and more if it cannot keep up. */
    if (this->next_draw_tick < now - ALLOWED_DRIFT * this->GetDrawInterval()) this->next_draw_tick = now;
 
    /* Locking video buffer can block (especially with vsync enabled), do it before taking game state lock. */
    this->LockVideoBuffer();
 
    {
      /* Tell the game-thread to stop so we can have a go. */
      std::lock_guard<std::mutex> lock_wait(this->game_thread_wait_mutex);
      std::lock_guard<std::mutex> lock_state(this->game_state_mutex);
 
      /* Keep the interactive randomizer a bit more random by requesting
       * new values when-ever we can. */
      InteractiveRandom();
 
      this->DrainCommandQueue();
 
      while (this->PollEvent()) {}
      this->InputLoop();
 
      /* Check if the fast-forward button is still pressed. */
      if (fast_forward_key_pressed && !_networking && _game_mode != GM_MENU) {
        ChangeGameSpeed(true);
        this->fast_forward_via_key = true;
      } else if (this->fast_forward_via_key) {
        ChangeGameSpeed(false);
        this->fast_forward_via_key = false;
      }
 
      ::InputLoop();
 
      /* Prevent drawing when switching mode, as windows can be removed when they should still appear. */
      if (_game_mode == GM_BOOTSTRAP || _switch_mode == SM_NONE || HasModalProgress()) {
        ::UpdateWindows();
      }
 
      this->PopulateSystemSprites();
    }
 
    this->CheckPaletteAnim();
    this->Paint();
 
    this->UnlockVideoBuffer();
 
    /* Wait till the first successful drawing tick before marking the driver as operational. */
    static bool first_draw_tick = true;
    if (first_draw_tick) {
      first_draw_tick = false;
      DriverFactoryBase::MarkVideoDriverOperational();
    }
  }
}
void VideoDriver::Tick() {…}
 
void VideoDriver::SleepTillNextTick()
{
  auto next_tick = this->next_draw_tick;
  auto now = std::chrono::steady_clock::now();
 
  if (!this->is_game_threaded) {
    next_tick = min(next_tick, this->next_game_tick);
  }
 
  if (next_tick > now) {
    std::this_thread::sleep_for(next_tick - now);
  }
}
void VideoDriver::SleepTillNextTick() {…}
 
/* static */ std::string VideoDriver::GetCaption()
{
  return fmt::format("OpenTTD {}", _openttd_revision);
}
/* static */ std::string VideoDriver::GetCaption() {…}