Files
@ r24961:a439f32fb4d8
Branch filter:
Location: cpp/openttd-patchpack/source/src/video/video_driver.hpp
r24961:a439f32fb4d8
7.6 KiB
text/x-c++hdr
Update: Translations from eints
swedish: 60 changes by kustridaren
norwegian (bokmal): 12 changes by buzzCraft
czech: 82 changes by PatrikSamuelTauchim, 1 change by tomas-vl
italian: 86 changes by AlphaJack, 9 changes by federico1564S
german: 16 changes by ebla71
romanian: 10 changes by ALEX11BR
ukrainian: 3 changes by StepanIvasyn
spanish: 1 change by MontyMontana
swedish: 60 changes by kustridaren
norwegian (bokmal): 12 changes by buzzCraft
czech: 82 changes by PatrikSamuelTauchim, 1 change by tomas-vl
italian: 86 changes by AlphaJack, 9 changes by federico1564S
german: 16 changes by ebla71
romanian: 10 changes by ALEX11BR
ukrainian: 3 changes by StepanIvasyn
spanish: 1 change by MontyMontana
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 | /*
* 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 "../settings_type.h"
#include "../zoom_type.h"
#include <chrono>
#include <vector>
extern std::string _ini_videodriver;
extern std::vector<Dimension> _resolutions;
extern Dimension _cur_resolution;
extern bool _rightclick_emulate;
/** 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:
/**
* 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;
/**
* Callback invoked after the blitter was changed.
* This may only be called between AcquireBlitterLock and ReleaseBlitterLock.
* @return True if no error.
*/
virtual bool AfterBlitterChange()
{
return true;
}
/**
* Acquire any lock(s) required to be held when changing blitters.
* These lock(s) may not be acquired recursively.
*/
virtual void AcquireBlitterLock() { }
/**
* Release any lock(s) required to be held when changing blitters.
* These lock(s) may not be acquired recursively.
*/
virtual void ReleaseBlitterLock() { }
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;
}
/**
* 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 suggested default GUI zoom taking screen DPI into account.
*/
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;
}
/**
* 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() {}
/**
* Thread function for threaded drawing.
*/
virtual void PaintThread() {}
/**
* 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; };
/**
* Run the game for a single tick, processing boththe game-tick and draw-tick.
* @returns True if the driver should redraw the screen.
*/
bool Tick();
/**
* Sleep till the next tick is about to happen.
*/
void SleepTillNextTick();
std::chrono::steady_clock::duration GetGameInterval()
{
return std::chrono::milliseconds(MILLISECONDS_PER_TICK);
}
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;
};
#endif /* VIDEO_VIDEO_DRIVER_HPP */
|