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