diff options
author | Patric Stout <truebrain@openttd.org> | 2021-02-17 15:04:46 +0100 |
---|---|---|
committer | Patric Stout <github@truebrain.nl> | 2021-02-19 10:43:15 +0100 |
commit | c81c6e5eb7a0e991039b7662868e87a8d2fe3415 (patch) | |
tree | 99be2e476e68136db5f64fe34e606f9a7a418211 /src/video/sdl2_v.cpp | |
parent | 5bfa0145057f2b67ed05d491abea82df4cc10d6b (diff) | |
download | openttd-c81c6e5eb7a0e991039b7662868e87a8d2fe3415.tar.xz |
Add: draw the screen at a steady pace, also during fast-forward
During fast-forward, the game was drawing as fast as it could. This
means that the fast-forward was limited also by how fast we could
draw, something that people in general don't expect.
To give an extreme case, if you are fully zoomed out on a busy
map, fast-forward would be mostly limited because of the time it
takes to draw the screen.
By decoupling the draw-tick and game-tick, we can keep the pace
of the draw-tick the same while speeding up the game-tick. To use
the extreme case as example again, if you are fully zoomed out
now, the screen only redraws 33.33 times per second, fast-forwarding
or not. This means fast-forward is much more likely to go at the
same speed, no matter what you are looking at.
Diffstat (limited to 'src/video/sdl2_v.cpp')
-rw-r--r-- | src/video/sdl2_v.cpp | 57 |
1 files changed, 26 insertions, 31 deletions
diff --git a/src/video/sdl2_v.cpp b/src/video/sdl2_v.cpp index 6db220470..157ffcd64 100644 --- a/src/video/sdl2_v.cpp +++ b/src/video/sdl2_v.cpp @@ -776,8 +776,18 @@ void VideoDriver_SDL::LoopOnce() last_realtime_tick += delta; } - if (cur_ticks >= next_tick || (_fast_forward && !_pause_mode)) { - next_tick = cur_ticks + std::chrono::milliseconds(MILLISECONDS_PER_TICK); + if (cur_ticks >= next_game_tick || (_fast_forward && !_pause_mode)) { + next_game_tick = cur_ticks + std::chrono::milliseconds(MILLISECONDS_PER_TICK); + + /* The gameloop is the part that can run asynchronously. The rest + * except sleeping can't. */ + if (_draw_mutex != nullptr) draw_lock.unlock(); + GameLoop(); + if (_draw_mutex != nullptr) draw_lock.lock(); + } + + if (cur_ticks >= next_draw_tick) { + next_draw_tick = cur_ticks + std::chrono::milliseconds(MILLISECONDS_PER_TICK); bool old_ctrl_pressed = _ctrl_pressed; @@ -792,48 +802,33 @@ void VideoDriver_SDL::LoopOnce() (keys[SDL_SCANCODE_DOWN] ? 8 : 0); if (old_ctrl_pressed != _ctrl_pressed) HandleCtrlChanged(); - /* The gameloop is the part that can run asynchronously. The rest - * except sleeping can't. */ - if (_draw_mutex != nullptr) draw_lock.unlock(); - - GameLoop(); - - if (_draw_mutex != nullptr) draw_lock.lock(); - + InputLoop(); UpdateWindows(); this->CheckPaletteAnim(); - } else { - /* Release the thread while sleeping */ - if (_draw_mutex != nullptr) { - draw_lock.unlock(); - CSleep(1); - draw_lock.lock(); + + if (_draw_mutex != nullptr && !HasModalProgress()) { + _draw_signal->notify_one(); } else { -/* Emscripten is running an event-based mainloop; there is already some - * downtime between each iteration, so no need to sleep. */ -#ifndef __EMSCRIPTEN__ - CSleep(1); -#endif + Paint(); } - - NetworkDrawChatMessage(); - DrawMouseCursor(); } - /* End of the critical part. */ - if (_draw_mutex != nullptr && !HasModalProgress()) { - _draw_signal->notify_one(); - } else { - /* Oh, we didn't have threads, then just draw unthreaded */ - Paint(); +/* Emscripten is running an event-based mainloop; there is already some + * downtime between each iteration, so no need to sleep. */ +#ifndef __EMSCRIPTEN__ + if (!_fast_forward || _pause_mode) { + if (_draw_mutex != nullptr) draw_lock.unlock(); + CSleep(1); + if (_draw_mutex != nullptr) draw_lock.lock(); } +#endif } void VideoDriver_SDL::MainLoop() { cur_ticks = std::chrono::steady_clock::now(); last_realtime_tick = cur_ticks; - next_tick = cur_ticks; + next_game_tick = cur_ticks; this->CheckPaletteAnim(); |