43std::atomic<bool> _exit_game;
70static const uint8_t *_colour_remap_ptr;
73static const uint DIRTY_BLOCK_HEIGHT = 8;
74static const uint DIRTY_BLOCK_WIDTH = 64;
76static size_t _dirty_blocks_per_row = 0;
77static size_t _dirty_blocks_per_column = 0;
78static std::vector<uint8_t> _dirty_blocks;
79extern uint _dirty_block_colour;
81void GfxScroll(
int left,
int top,
int width,
int height,
int xo,
int yo)
85 if (xo == 0 && yo == 0)
return;
87 if (_cursor.visible) UndrawMouseCursor();
91 blitter->
ScrollBuffer(_screen.dst_ptr, left, top, width, height, xo, yo);
111void GfxFillRect(
int left,
int top,
int right,
int bottom,
const std::variant<PixelColour, PaletteID> &colour,
FillRectMode mode)
116 const int otop = top;
117 const int oleft = left;
120 if (left > right || top > bottom)
return;
121 if (right < dpi->left || left >= dpi->left + dpi->width)
return;
122 if (bottom < dpi->top || top >= dpi->top + dpi->height)
return;
124 if ( (left -= dpi->left) < 0) left = 0;
125 right = right - dpi->left + 1;
126 if (right > dpi->width) right = dpi->width;
130 if ( (top -= dpi->top) < 0) top = 0;
131 bottom = bottom - dpi->top + 1;
132 if (bottom > dpi->height) bottom = dpi->height;
136 dst = blitter->
MoveTo(dpi->dst_ptr, left, top);
140 blitter->
DrawRect(dst, right, bottom, std::get<PixelColour>(colour));
148 uint8_t bo = (oleft - left + dpi->left + otop - top + dpi->top) & 1;
151 for (
int i = (bo ^= 1); i < right; i += 2) blitter->
SetPixel(dst, i, 0, pc);
152 dst = blitter->
MoveTo(dst, 0, 1);
153 }
while (--bottom > 0);
159typedef std::pair<Point, Point> LineSegment;
171 std::vector<LineSegment> segments;
172 if (shape.size() < 3)
return segments;
173 segments.reserve(shape.size());
176 Point prev = shape.back();
179 for (
Point pt : shape) {
185 segments.emplace_back(pt, prev);
186 }
else if (prev.
y < pt.y) {
187 segments.emplace_back(prev, pt);
217 segments.erase(std::remove_if(segments.begin(), segments.end(), [dpi](
const LineSegment &s) { return s.second.y <= 0 || s.first.y >= dpi->height; }), segments.end());
220 if (segments.empty())
return;
223 std::sort(segments.begin(), segments.end(), [](
const LineSegment &a,
const LineSegment &b) { return a.first.y < b.first.y; });
226 std::vector<LineSegment> active;
229 std::vector<int> intersections;
232 intersections.reserve(4);
235 int y = segments.front().first.y;
236 std::vector<LineSegment>::iterator nextseg = segments.begin();
237 while (!active.empty() || nextseg != segments.end()) {
239 active.erase(std::remove_if(active.begin(), active.end(), [y](
const LineSegment &s) { return s.second.y == y; }), active.end());
242 while (nextseg != segments.end() && nextseg->first.y == y) {
243 active.push_back(*nextseg);
252 if (y >= dpi->height)
return;
255 intersections.clear();
256 for (
const LineSegment &s : active) {
257 const int sdx = s.second.x - s.first.x;
258 const int sdy = s.second.y - s.first.y;
259 const int ldy = y - s.first.y;
260 const int x = s.first.x + sdx * ldy / sdy;
261 intersections.push_back(x);
265 std::sort(intersections.begin(), intersections.end());
266 for (
size_t i = 1; i < intersections.size(); i += 2) {
268 const int x1 = std::max(0, intersections[i - 1]);
269 const int x2 = std::min(intersections[i], dpi->width);
270 if (x2 < 0)
continue;
271 if (x1 >= dpi->width)
continue;
274 void *dst = blitter->
MoveTo(dpi->dst_ptr, x1, y);
277 blitter->
DrawRect(dst, x2 - x1, 1, std::get<PixelColour>(colour));
286 for (
int x = (x1 + y) & 1; x < x2 - x1; x += 2) {
313static inline void GfxDoDrawLine(
void *video,
int x,
int y,
int x2,
int y2,
int screen_width,
int screen_height,
PixelColour colour,
int width,
int dash = 0)
319 if (y2 == y || x2 == x) {
321 blitter->
DrawLine(video, x, y, x2, y2, screen_width, screen_height, colour, width, dash);
325 int grade_y = y2 - y;
326 int grade_x = x2 - x;
329 int extra = (int)
CeilDiv(3 * width, 4);
330 Rect clip = { -extra, -extra, screen_width - 1 + extra, screen_height - 1 + extra };
334 while (INT_MAX /
abs(grade_y) < std::max(
abs(clip.left - x),
abs(clip.right - x))) {
341 if (grade_x == 0) grade_x = 1;
347 int left_isec_y = y + (clip.left - x) * grade_y / grade_x;
348 int right_isec_y = y + (clip.right - x) * grade_y / grade_x;
349 if ((left_isec_y > clip.bottom + margin && right_isec_y > clip.bottom + margin) ||
350 (left_isec_y < clip.top - margin && right_isec_y < clip.top - margin)) {
360 blitter->
DrawLine(video, x, y, x2, y2, screen_width, screen_height, colour, width, dash);
382 if (x + width / 2 < 0 && x2 + width / 2 < 0 )
return false;
383 if (y + width / 2 < 0 && y2 + width / 2 < 0 )
return false;
384 if (x - width / 2 > dpi->width && x2 - width / 2 > dpi->width )
return false;
385 if (y - width / 2 > dpi->height && y2 - width / 2 > dpi->height)
return false;
389void GfxDrawLine(
int x,
int y,
int x2,
int y2,
PixelColour colour,
int width,
int dash)
393 GfxDoDrawLine(dpi->dst_ptr, x, y, x2, y2, dpi->width, dpi->height, colour, width, dash);
397void GfxDrawLineUnscaled(
int x,
int y,
int x2,
int y2,
PixelColour colour)
421void DrawBox(
int x,
int y,
int dx1,
int dy1,
int dx2,
int dy2,
int dx3,
int dy3)
440 GfxDrawLineUnscaled(x, y, x + dx1, y + dy1, colour);
441 GfxDrawLineUnscaled(x, y, x + dx2, y + dy2, colour);
442 GfxDrawLineUnscaled(x, y, x + dx3, y + dy3, colour);
444 GfxDrawLineUnscaled(x + dx1, y + dy1, x + dx1 + dx2, y + dy1 + dy2, colour);
445 GfxDrawLineUnscaled(x + dx1, y + dy1, x + dx1 + dx3, y + dy1 + dy3, colour);
446 GfxDrawLineUnscaled(x + dx2, y + dy2, x + dx2 + dx1, y + dy2 + dy1, colour);
447 GfxDrawLineUnscaled(x + dx2, y + dy2, x + dx2 + dx3, y + dy2 + dy3, colour);
448 GfxDrawLineUnscaled(x + dx3, y + dy3, x + dx3 + dx1, y + dy3 + dy1, colour);
449 GfxDrawLineUnscaled(x + dx3, y + dy3, x + dx3 + dx2, y + dy3 + dy2, colour);
461 GfxDrawLine(r.left, r.top, r.right, r.top, colour, width, dash);
462 GfxDrawLine(r.left, r.top, r.left, r.bottom, colour, width, dash);
463 GfxDrawLine(r.right, r.top, r.right, r.bottom, colour, width, dash);
464 GfxDrawLine(r.left, r.bottom, r.right, r.bottom, colour, width, dash);
520 int max_w = right - left + 1;
526 truncation &= max_w < w;
527 int truncation_width = 0;
529 std::optional<Layouter> truncation_layout;
538 truncation_width = truncation_layout->GetBounds().width;
544 min_x += truncation_width;
545 offset_x = w - max_w;
547 max_x -= truncation_width;
564 right = left + w - 1;
570 right = left + w - 1;
574 left = right + 1 - w;
585 int dpi_left = dpi->left;
586 int dpi_right = dpi->left + dpi->width - 1;
589 for (
size_t run_index = 0; run_index < line.
CountRuns(); run_index++) {
600 last_colour = colour;
605 GlyphID glyph = glyphs[i];
608 if (glyph == 0xFFFF)
continue;
610 int begin_x = positions[i].left + left;
611 int end_x = positions[i].right + left;
612 int top = positions[i].top + y;
615 if (truncation && (begin_x < min_x || end_x > max_x))
continue;
619 if (begin_x + sprite->
x_offs > dpi_right || begin_x + sprite->
x_offs + sprite->
width < dpi_left)
continue;
621 if (do_shadow && (glyph & SPRITE_GLYPH) != 0)
continue;
623 GfxMainBlitter(sprite, begin_x + (do_shadow ? shadow_offset : 0), top + (do_shadow ? shadow_offset : 0),
BlitterMode::ColourRemap);
630 for (
bool do_shadow : {
true,
false}) {
631 ExtendedTextColour colour = draw_line(line, do_shadow, left - offset_x, min_x, max_x, truncation, default_colour);
635 draw_line(*truncation_layout->front(), do_shadow, x, INT32_MIN, INT32_MAX,
false, colour);
669 int extra = max_height / 2;
671 if (_cur_dpi->top + _cur_dpi->height + extra < top || _cur_dpi->top > top + max_height + extra ||
672 _cur_dpi->left + _cur_dpi->width + extra < left || _cur_dpi->left > right + extra) {
676 Layouter layout(str, INT32_MAX, fontsize);
677 if (layout.empty())
return 0;
679 return DrawLayoutLine(*layout.front(), top, left, right, align, underline,
true, colour);
714 Layouter layout(str, maxw, fontsize);
738 return (uint)layout.size();
784 int maxw = right - left + 1;
785 int maxh = bottom - top + 1;
789 if (maxh <= 0)
return top;
791 Layouter layout(str, maxw, fontsize);
800 y =
RoundDivSU(bottom + top - total_height, 2);
804 y = bottom - total_height;
807 default: NOT_REACHED();
811 int first_line = bottom;
813 for (
const auto &line : layout) {
815 int line_height = line->GetLeading();
816 if (y >= top && y + line_height - 1 <= bottom) {
817 last_line = y + line_height;
818 if (first_line > y) first_line = y;
820 DrawLayoutLine(*line, y, left, right, align, underline,
false, colour);
873 int extra = max_height / 2;
875 if (_cur_dpi->top + _cur_dpi->height + extra < top || _cur_dpi->top > bottom + extra ||
876 _cur_dpi->left + _cur_dpi->width + extra < left || _cur_dpi->left > right + extra) {
896 Layouter layout(str, INT32_MAX, start_fontsize);
921 for (
auto str : list) {
936 for (
auto str : list) {
970 if (offset !=
nullptr) {
1011 }
else if (pal != PAL_NONE) {
1039 }
else if (pal != PAL_NONE) {
1064template <
int ZOOM_BASE,
bool SCALED_XY>
1067 const DrawPixelInfo *dpi = (dst !=
nullptr) ? dst : _cur_dpi;
1080 if (sub ==
nullptr) {
1088 int clip_left = std::max(0, -sprite->
x_offs + sub->left * ZOOM_BASE );
1089 int clip_top = std::max(0, -sprite->
y_offs + sub->top * ZOOM_BASE );
1090 int clip_right = std::max(0, sprite->
width - (-sprite->
x_offs + (sub->right + 1) * ZOOM_BASE));
1091 int clip_bottom = std::max(0, sprite->
height - (-sprite->
y_offs + (sub->bottom + 1) * ZOOM_BASE));
1093 if (clip_left + clip_right >= sprite->
width)
return;
1094 if (clip_top + clip_bottom >= sprite->
height)
return;
1112 bp.
dst = dpi->dst_ptr;
1113 bp.
pitch = dpi->pitch;
1114 bp.
remap = _colour_remap_ptr;
1116 assert(sprite->
width > 0);
1117 assert(sprite->
height > 0);
1119 if (bp.
width <= 0)
return;
1120 if (bp.
height <= 0)
return;
1122 y -= SCALED_XY ?
ScaleByZoom(dpi->top, zoom) : dpi->top;
1126 bp.
height -= -y_unscaled;
1127 if (bp.
height <= 0)
return;
1131 bp.
top = y_unscaled;
1138 if (bp.
height <= 0)
return;
1141 x -= SCALED_XY ?
ScaleByZoom(dpi->left, zoom) : dpi->left;
1145 bp.
width -= -x_unscaled;
1146 if (bp.
width <= 0)
return;
1150 bp.
left = x_unscaled;
1157 if (bp.
width <= 0)
return;
1171 if (topleft <= clicked && clicked <= bottomright) {
1172 uint offset = (((size_t)clicked - (size_t)topleft) / (blitter->
GetScreenDepth() / 8)) % bp.
pitch;
1173 if (offset < (uint)bp.
width) {
1192 if (zoom < _settings_client.gui.zoom_min || zoom >
_settings_client.gui.zoom_max)
return nullptr;
1201 size_t dim_size =
static_cast<size_t>(dim.
width) * dim.
height;
1202 std::unique_ptr<uint32_t[]> result = std::make_unique<uint32_t[]>(dim_size);
1207 dpi.dst_ptr = result.get();
1208 dpi.pitch = dim.
width;
1211 dpi.width = dim.
width;
1215 dim_size =
static_cast<size_t>(dim.
width) * dim.
height;
1218 std::unique_ptr<uint8_t[]> pal_buffer{};
1220 pal_buffer = std::make_unique<uint8_t[]>(dim_size);
1221 dpi.dst_ptr = pal_buffer.get();
1231 uint32_t *dst = result.get();
1232 const uint8_t *src = pal_buffer.get();
1233 for (
size_t i = 0; i < dim_size; ++i) {
1260 for (uint i = 0; i != 224; i++) {
1288 for (
char c =
'0'; c <=
'9'; c++) {
1306 for (
char c =
'9'; c >=
'0'; c--) {
1308 if (w <= width)
continue;
1312 if (c !=
'0') front = c -
'0';
1314 return {front, next};
1317void ScreenSizeChanged()
1319 _dirty_blocks_per_row =
CeilDiv(_screen.width, DIRTY_BLOCK_WIDTH);
1320 _dirty_blocks_per_column =
CeilDiv(_screen.height, DIRTY_BLOCK_HEIGHT);
1321 _dirty_blocks.resize(_dirty_blocks_per_column * _dirty_blocks_per_row);
1328 _cursor.visible =
false;
1335void UndrawMouseCursor()
1341 if (_screen.dst_ptr ==
nullptr)
return;
1343 if (_cursor.visible) {
1345 _cursor.visible =
false;
1346 blitter->
CopyFromBuffer(blitter->
MoveTo(_screen.dst_ptr, _cursor.draw_pos.x, _cursor.draw_pos.y), _cursor_backup.GetBuffer(), _cursor.draw_size.x, _cursor.draw_size.y);
1351void DrawMouseCursor()
1357 if (_screen.dst_ptr ==
nullptr)
return;
1362 if (!_cursor.in_window)
return;
1365 if (_cursor.visible) {
1366 if (!_cursor.dirty)
return;
1367 UndrawMouseCursor();
1371 int left = _cursor.pos.x + _cursor.total_offs.x;
1372 int width = _cursor.total_size.x;
1377 if (left + width > _screen.width) {
1378 width = _screen.width - left;
1380 if (width <= 0)
return;
1382 int top = _cursor.pos.y + _cursor.total_offs.y;
1383 int height = _cursor.total_size.y;
1388 if (top + height > _screen.height) {
1389 height = _screen.height - top;
1391 if (height <= 0)
return;
1393 _cursor.draw_pos.x = left;
1394 _cursor.draw_pos.y = top;
1395 _cursor.draw_size.x = width;
1396 _cursor.draw_size.y = height;
1398 uint8_t *buffer = _cursor_backup.Allocate(blitter->
BufferSize(_cursor.draw_size.x, _cursor.draw_size.y));
1401 blitter->
CopyToBuffer(blitter->
MoveTo(_screen.dst_ptr, _cursor.draw_pos.x, _cursor.draw_pos.y), buffer, _cursor.draw_size.x, _cursor.draw_size.y);
1404 _cur_dpi = &_screen;
1405 for (
const auto &cs : _cursor.sprites) {
1406 DrawSprite(cs.image.sprite, cs.image.pal, _cursor.pos.x + cs.pos.x, _cursor.pos.y + cs.pos.y);
1411 _cursor.visible =
true;
1412 _cursor.dirty =
false;
1427 assert(right <= _screen.width && bottom <= _screen.height);
1428 if (_cursor.visible) {
1429 if (right > _cursor.draw_pos.x &&
1430 left < _cursor.draw_pos.x + _cursor.draw_size.x &&
1431 bottom > _cursor.draw_pos.y &&
1432 top < _cursor.draw_pos.y + _cursor.draw_size.y) {
1433 UndrawMouseCursor();
1453 auto is_dirty = [](
auto block) ->
bool {
return block != 0; };
1454 auto block = _dirty_blocks.begin();
1456 for (
size_t x = 0; x < _dirty_blocks_per_row; ++x) {
1457 auto last_of_column = block + _dirty_blocks_per_column;
1458 for (
size_t y = 0; y < _dirty_blocks_per_column; ++y, ++block) {
1459 if (!is_dirty(*block))
continue;
1462 size_t height = std::find_if_not(block + 1, last_of_column, is_dirty) - block;
1466 std::fill_n(block, height, 0);
1469 auto block_right = block;
1470 for (
size_t x_right = x + 1; x_right < _dirty_blocks_per_row; ++x_right, ++width) {
1471 block_right += _dirty_blocks_per_column;
1472 auto last_right = block_right + height;
1474 if (std::find_if_not(block_right, last_right, is_dirty) != last_right)
break;
1477 std::fill_n(block_right, height, 0);
1480 int left =
static_cast<int>(x * DIRTY_BLOCK_WIDTH);
1481 int top =
static_cast<int>(y * DIRTY_BLOCK_HEIGHT);
1482 int right = left +
static_cast<int>(width * DIRTY_BLOCK_WIDTH);
1483 int bottom = top +
static_cast<int>(height * DIRTY_BLOCK_HEIGHT);
1490 if (left < right && top < bottom) {
1496 ++_dirty_block_colour;
1517 if (left < 0) left = 0;
1518 if (top < 0) top = 0;
1519 if (right > _screen.width) right = _screen.width;
1520 if (bottom > _screen.height) bottom = _screen.height;
1522 if (left >= right || top >= bottom)
return;
1529 left /= DIRTY_BLOCK_WIDTH;
1530 top /= DIRTY_BLOCK_HEIGHT;
1531 right =
CeilDiv(right, DIRTY_BLOCK_WIDTH);
1532 int height =
CeilDiv(bottom, DIRTY_BLOCK_HEIGHT) - top;
1534 assert(left < right && height > 0);
1536 for (; left < right; ++left) {
1537 size_t offset = _dirty_blocks_per_column * left + top;
1538 std::fill_n(_dirty_blocks.begin() + offset, height, 0xFF);
1577 if ((left -= o->left) < 0) {
1579 if (width <= 0)
return false;
1586 if (width > o->width - left) {
1587 width = o->width - left;
1588 if (width <= 0)
return false;
1592 if ((top -= o->top) < 0) {
1594 if (height <= 0)
return false;
1601 n->dst_ptr = blitter->
MoveTo(o->dst_ptr, left, top);
1602 n->pitch = o->pitch;
1604 if (height > o->height - top) {
1605 height = o->height - top;
1606 if (height <= 0)
return false;
1623 for (
const auto &cs : _cursor.sprites) {
1633 _cursor.total_offs = offs;
1634 _cursor.total_size = size;
1638 int right = std::max(_cursor.total_offs.x + _cursor.total_size.x, offs.
x + size.
x);
1639 int bottom = std::max(_cursor.total_offs.y + _cursor.total_size.y, offs.
y + size.
y);
1640 if (offs.
x < _cursor.total_offs.x) _cursor.total_offs.x = offs.
x;
1641 if (offs.
y < _cursor.total_offs.y) _cursor.total_offs.y = offs.
y;
1642 _cursor.total_size.x = right - _cursor.total_offs.x;
1643 _cursor.total_size.y = bottom - _cursor.total_offs.y;
1647 _cursor.dirty =
true;
1657 if (_cursor.sprites.size() == 1 && _cursor.sprites[0].image.sprite == cursor && _cursor.sprites[0].image.pal == pal)
return;
1659 _cursor.sprites.clear();
1660 _cursor.sprites.emplace_back(cursor, pal, 0, 0);
1665static void SwitchAnimatedCursor()
1667 if (_cursor.animate_cur == std::end(_cursor.animate_list)) {
1668 _cursor.animate_cur = std::begin(_cursor.animate_list);
1671 assert(!_cursor.sprites.empty());
1672 SetCursorSprite(_cursor.animate_cur->sprite, _cursor.sprites[0].image.pal);
1674 _cursor.animate_timeout = _cursor.animate_cur->display_time;
1675 ++_cursor.animate_cur;
1680 if (_cursor.animate_timeout != 0 && --_cursor.animate_timeout == 0) {
1681 SwitchAnimatedCursor();
1691 assert(!_cursor.sprites.empty());
1708 _cursor.animate_timeout = 0;
1720 assert(!_cursor.sprites.empty());
1721 _cursor.animate_list = table;
1722 _cursor.animate_cur = std::end(table);
1723 _cursor.sprites[0].image.pal = PAL_NONE;
1724 SwitchAnimatedCursor();
1751 this->
delta.x = delta_x;
1752 this->
delta.y = delta_y;
1767 return this->
delta.x != 0 || this->
delta.y != 0;
1768 }
else if (this->
pos.x != x || this->pos.y != y) {
1777bool ChangeResInGame(
int width,
int height)
1782bool ToggleFullScreen(
bool fs)
1791void SortResolutions()
1808 float xs = _screen.width / width;
1809 float ys = _screen.height / height;
1810 int scale = std::min(xs, ys) * 100;
1812 return Clamp((scale / 25) * 25, MIN_INTERFACE_SCALE, MAX_INTERFACE_SCALE);
1885 auto zoom_shift = old_gui_zoom -
_gui_zoom;
1888 w->left = (w->left *
_gui_scale) / old_scale;
1891 if (w->viewport !=
nullptr) {
1899void ChangeGameSpeed(
bool enable_fast_forward)
1901 if (enable_fast_forward) {
void UpdateAllVirtCoords()
Update the viewport coordinates of all signs.
This file defines all the the animated cursors.
static constexpr std::span< const AnimCursor > _animcursors[]
This is an array of pointers to all the animated cursor definitions we have above.
Class for backupping variables and making sure they are restored later.
BlitterMode
The modes of blitting we can do.
@ Transparent
Perform transparency darkening remapping.
@ CrashRemap
Perform a crash remapping.
@ BlackRemap
Perform remapping to a completely blackened sprite.
@ Normal
Perform the simple blitting.
@ TransparentRemap
Perform transparency colour remapping.
@ ColourRemap
Perform a colour remapping.
static constexpr uint GB(const T x, const uint8_t s, const uint8_t n)
Fetch n bits from x, started at bit s.
constexpr bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
constexpr bool Test(Tvalue_type value) const
Test if the value-th bit is set.
static Blitter * GetCurrentBlitter()
Get the current active blitter (always set by calling SelectBlitter).
How all blitters should look like.
virtual void * MoveTo(void *video, int x, int y)=0
Move the destination pointer the requested amount x and y, keeping in mind any pitch and bpp of the r...
virtual uint8_t GetScreenDepth()=0
Get the screen depth this blitter works for.
virtual size_t BufferSize(uint width, uint height)=0
Calculate how much memory there is needed for an image of this size in the video-buffer.
virtual void DrawLine(void *video, int x, int y, int x2, int y2, int screen_width, int screen_height, PixelColour colour, int width, int dash=0)=0
Draw a line with a given colour.
virtual void DrawColourMappingRect(void *dst, int width, int height, PaletteID pal)=0
Draw a colourtable to the screen.
virtual void SetPixel(void *video, int x, int y, PixelColour colour)=0
Draw a pixel with a given colour on the video-buffer.
virtual void Draw(Blitter::BlitterParams *bp, BlitterMode mode, ZoomLevel zoom)=0
Draw an image to the screen, given an amount of params defined above.
virtual void CopyToBuffer(const void *video, void *dst, int width, int height)=0
Copy from the screen to a buffer.
virtual void DrawRect(void *video, int width, int height, PixelColour colour)=0
Make a single horizontal line in a single colour on the video-buffer.
virtual void CopyFromBuffer(void *video, const void *src, int width, int height)=0
Copy from a buffer to the screen.
virtual void ScrollBuffer(void *video, int &left, int &top, int &width, int &height, int scroll_x, int scroll_y)=0
Scroll the videobuffer some 'x' and 'y' value.
Font cache for basic fonts.
virtual const Sprite * GetGlyph(GlyphID key)=0
Get the glyph (sprite) of the given key.
static void ClearFontCaches(FontSizes fontsizes)
Clear cached information for the specified font caches.
virtual bool GetDrawGlyphShadow()=0
Do we need to draw a glyph shadow?
Container with information about a font.
ExtendedTextColour colour
The text colour.
FontCache & GetFontCache() const
Get the font cache of this font.
FontSize fontsize
The font size.
The layouter performs all the layout work.
Dimension GetBounds()
Get the boundaries of this paragraph.
A single line worth of VisualRuns.
virtual int GetLeading() const =0
Get the font leading, or distance between the baselines of consecutive lines.
virtual const VisualRun & GetVisualRun(size_t run) const =0
Get a reference to the given run.
virtual int GetWidth() const =0
Get the width of this line.
virtual size_t CountRuns() const =0
Get the number of runs in this line.
Visual run contains data about the bit of text with the same font.
virtual std::span< const GlyphID > GetGlyphs() const =0
Get the glyphs to draw.
virtual std::span< const Position > GetPositions() const =0
Get the positions for each of the glyphs.
virtual size_t GetGlyphCount() const =0
Get the number of glyphs.
virtual const Font & GetFont() const =0
Get the font.
A reusable buffer that can be used for places that temporary allocate a bit of memory and do that ver...
virtual bool ToggleFullscreen(bool fullscreen)=0
Change the full screen setting.
virtual void ClearSystemSprites()
Clear all cached sprites.
virtual void MakeDirty(int left, int top, int width, int height)=0
Mark a particular area dirty.
virtual bool ChangeResolution(int w, int h)=0
Change the resolution of the window.
static VideoDriver * GetInstance()
Get the currently active instance of the video driver.
#define Debug(facility, severity, format_string,...)
Output a line of debugging information.
@ Driver
Driver message facility.
@ Critical
Critical, user should know about this.
std::vector< Dimension > _resolutions
List of resolutions.
constexpr std::underlying_type_t< enum_type > to_underlying(enum_type e)
Implementation of std::to_underlying (from C++23).
EnumClassIndexContainer< std::array< T, to_underlying(N)>, Index > EnumIndexArray
A typedef for EnumClassIndexContainer using std::array as the backing container type.
Factory to 'query' all available blitters.
int GetCharacterHeight(FontSize size)
Get height of a character for a given font size.
const Sprite * GetGlyph(FontSize size, char32_t key)
Get the Sprite for a glyph.
uint GetGlyphWidth(FontSize size, char32_t key)
Get the width of a glyph.
Dimension maxdim(const Dimension &d1, const Dimension &d2)
Compute bounding box of both dimensions.
@ ForceRight
Force align to the right.
@ Centre
Align to the centre.
@ ForceLeft
Force align to the left.
int CentreBounds(int min, int max, int size)
Determine where to position a centred object.
@ Bottom
Align to the bottom.
@ Middle
Align to the middle.
bool DrawStringMultiLineWithClipping(int left, int right, int top, int bottom, std::string_view str, ExtendedTextColour colour, Alignment align, bool underline, FontSize fontsize)
Draw a multiline string, possibly over multiple lines, if the region is within the current display cl...
int GetStringHeight(std::string_view str, int maxw, FontSize fontsize)
Calculates height of string (in pixels).
void SetMouseCursor(CursorID sprite, PaletteID pal)
Assign a single non-animated sprite to the cursor.
Dimension GetSpriteSize(SpriteID sprid, Point *offset, ZoomLevel zoom)
Get the size of a sprite.
void UpdateCursorSize()
Update cursor dimension.
static void SetCursorSprite(CursorID cursor, PaletteID pal)
Switch cursor to different sprite.
std::pair< uint8_t, uint8_t > GetBroadestDigit(FontSize size)
Determine the broadest digits for guessing the maximum width of a n-digit number.
static void GfxBlitter(const Sprite *const sprite, int x, int y, BlitterMode mode, const SubSprite *const sub, SpriteID sprite_id, ZoomLevel zoom, const DrawPixelInfo *dst=nullptr)
The code for setting up the blitter mode and sprite information before finally drawing the sprite.
int GetStringLineCount(std::string_view str, int maxw)
Calculates number of lines of string.
void LoadStringWidthTable(FontSizes fontsizes)
Initialize _stringwidth_table cache for the specified font sizes.
Dimension GetStringBoundingBox(std::string_view str, FontSize start_fontsize)
Return the string dimension in pixels.
static std::vector< LineSegment > MakePolygonSegments(std::span< const Point > shape, Point offset)
Make line segments from a polygon defined by points, translated by an offset.
Dimension GetStringListBoundingBox(std::span< const StringID > list, FontSize fontsize)
Get maximum dimension of a list of strings.
bool _screen_disable_anim
Disable palette animation (important for 32bpp-anim blitter during giant screenshot).
ZoomLevel _font_zoom
Sprite font Zoom level (not clamped).
uint GetStringListWidth(std::span< const StringID > list, FontSize fontsize)
Get maximum width of a list of strings.
uint16_t _game_speed
Current game-speed; 100 is 1x, 0 is infinite.
static BlitterMode GetBlitterMode(PaletteID pal)
Helper function to get the blitter mode for different types of palettes.
static void GfxDoDrawLine(void *video, int x, int y, int x2, int y2, int screen_width, int screen_height, PixelColour colour, int width, int dash=0)
Check line clipping by using a linear equation and draw the visible part of the line given by x/y and...
void SetMouseCursorBusy(bool busy)
Set or unset the ZZZ cursor.
void SetCursor(CursorID icon, PaletteID pal)
Assign an animation or a non-animated sprite to the cursor.
GameSessionStats _game_session_stats
Statistics about the current session.
void DrawRectOutline(const Rect &r, PixelColour colour, int width, int dash)
Draw the outline of a Rect.
void UpdateGUIZoom()
Resolve GUI zoom level, if auto-suggestion is requested.
int GetAutomaticScale()
Get the interface scale for automatic scaling.
ControlInputs _input_pressed
Control inputs that are currently pressed.
ControlInputs _input_clicked
Control inputs that have been actioned.
void DrawSprite(SpriteID img, PaletteID pal, int x, int y, const SubSprite *sub, ZoomLevel zoom)
Draw a sprite, not in a viewport.
void SetAnimatedMouseCursor(std::span< const AnimCursor > table)
Assign an animation to the cursor.
uint8_t GetDigitWidth(FontSize size)
Return the maximum width of single digit.
int _gui_scale_cfg
GUI scale in config.
static int GetTargetScale(float width, float height)
Calculate target interface scale for a given window size.
int GetMaximumScale()
Get the maximum interface scale.
Support8bpp _support8bpp
State of the support for 8bpp graphics.
uint8_t GetCharacterWidth(FontSize size, char32_t key)
Return width of character glyph.
DirectionKeys _dirkeys
Pressed direction keys.
void DrawSpriteViewport(SpriteID img, PaletteID pal, int x, int y, const SubSprite *sub)
Draw a sprite in a viewport.
PauseModes _pause_mode
The current pause mode.
void GfxFillPolygon(std::span< const Point > shape, const std::variant< PixelColour, PaletteID > &colour, FillRectMode mode)
Fill a polygon with colour.
static bool GfxPreprocessLine(DrawPixelInfo *dpi, int &x, int &y, int &x2, int &y2, int width)
Align parameters of a line to the given DPI and check simple clipping.
Dimension GetStringMultiLineBoundingBox(StringID str, const Dimension &suggestion)
Calculate string bounding box for multi-line strings.
std::unique_ptr< uint32_t[]> DrawSpriteToRgbaBuffer(SpriteID spriteId, ZoomLevel zoom)
Draws a sprite to a new RGBA buffer (see Colour union) instead of drawing to the screen.
void GfxFillRect(int left, int top, int right, int bottom, const std::variant< PixelColour, PaletteID > &colour, FillRectMode mode)
Applies a certain FillRectMode-operation to a rectangle [left, right] x [top, bottom] on the screen.
static EnumIndexArray< std::array< uint8_t, 244 >, FontSize, FontSize::End > _stringwidth_table
Cache containing width of often used characters.
SwitchMode _switch_mode
The next mainloop command.
int DrawStringMultiLine(int left, int right, int top, int bottom, std::string_view str, ExtendedTextColour colour, Alignment align, bool underline, FontSize fontsize)
Draw string, possibly over multiple lines.
void DrawBox(int x, int y, int dx1, int dy1, int dx2, int dy2, int dx3, int dy3)
Draws the projection of a parallelepiped.
int DrawString(int left, int right, int top, std::string_view str, ExtendedTextColour colour, Alignment align, bool underline, FontSize fontsize)
Draw string, possibly truncated to make it fit in its allocated space.
ZoomLevel _gui_zoom
GUI Zoom level.
static void SetColourRemap(ExtendedTextColour colour)
Set the colour remap to be for the given colour.
bool FillDrawPixelInfo(DrawPixelInfo *n, int left, int top, int width, int height)
Set up a clipping area for only drawing into a certain area.
static uint8_t _string_colourremap[3]
Recoloursprite for stringdrawing. The grf loader ensures that SpriteType::Font sprites only use colou...
static int DrawLayoutLine(const ParagraphLayouter::Line &line, int y, int left, int right, Alignment align, bool underline, bool truncation, ExtendedTextColour default_colour)
Drawing routine for drawing a laid out line of text.
bool AdjustGUIZoom(bool automatic)
Resolve GUI zoom level and adjust GUI to new zoom, if auto-suggestion is requested.
void DrawCharCentered(char32_t c, const Rect &r, TextColour colour)
Draw single character horizontally centered around (x,y).
int _gui_scale
GUI scale, 100 is 100%.
Functions related to the gfx engine.
void DrawOverlappedWindowForAll(int left, int top, int right, int bottom)
From a rectangle that needs redrawing, find the windows that intersect with the rectangle.
Palette _cur_palette
Current palette.
Functions related to laying out the texts.
uint32_t SpriteID
The number of a sprite, without mapping bits and colourtables.
Support8bpp
Modes for 8bpp support.
@ Recolour
Recolour sprite.
@ Normal
The most basic (normal) sprite.
FontSize
Available font sizes.
@ Small
Index of the small font in the font tables.
@ Large
Index of the large font in the font tables.
@ End
Marker for the end of the enumerations.
@ Normal
Index of the normal font in the font tables.
@ Monospace
Index of the monospaced font in the font tables.
uint32_t CursorID
The number of the cursor (sprite).
constexpr FontSizes FONTSIZES_ALL
Mask of all possible font sizes.
uint32_t PaletteID
The number of the palette.
EnumBitSet< ControlInput, uint8_t > ControlInputs
Bitset of ControlInput elements.
EnumBitSet< DirectionKey, uint8_t > DirectionKeys
Bitset of the direction keys.
@ NoShade
Do not add shading to this text colour.
@ IsPaletteColour
Colour value is already a real palette colour index, not an index of a StringColour.
@ Forced
Ignore colour changes from strings.
TextColour
Colour of the strings, see _string_colourmap in table/string_colours.h or docs/ottd-colourtext-palett...
FillRectMode
Define the operation GfxFillRect performs.
@ Recolour
Apply a recolour sprite to the screen content.
@ Checker
Draw only every second pixel, used for greying-out.
EnumBitSet< FontSize, uint8_t > FontSizes
Bitset of FontSize elements.
static const CursorID ANIMCURSOR_FLAG
Flag for saying a cursor sprite is an animated cursor.
static const CursorID SPR_CURSOR_ZZZ
static const CursorID SPR_CURSOR_MOUSE
static Rect _invalid_rect
The rect for repaint.
void AddDirtyBlock(int left, int top, int right, int bottom)
Extend the internal _invalid_rect rectangle to contain the rectangle defined by the given parameters.
void DrawDirtyBlocks()
Repaints the rectangle blocks which are marked as 'dirty'.
void MarkWholeScreenDirty()
This function mark the whole screen as dirty.
void RedrawScreenRect(int left, int top, int right, int bottom)
Repaints a specific rectangle of the screen.
#define Rect
Macro that prevents name conflicts between included headers.
#define Point
Macro that prevents name conflicts between included headers.
constexpr T abs(const T a)
Returns the absolute value of (scalar) variable.
constexpr int RoundDivSU(int a, uint b)
Computes round(a / b) for signed a and unsigned b.
constexpr uint CeilDiv(uint a, uint b)
Computes ceil(a / b) for non-negative a and b.
constexpr T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
bool _networking
are we in networking mode?
Basic functions/variables used all over the place.
void NetworkUndrawChatMessage()
Hide the chatbox.
Network functions used by other parts of OpenTTD.
Functions/types related to NewGRF debugging.
NewGrfDebugSpritePicker _newgrf_debug_sprite_picker
The sprite picker.
GameMode
Mode which defines the state of the game.
SwitchMode
Mode which defines what mode we're switching to.
EnumBitSet< PauseMode, uint8_t > PauseModes
Bitset of PauseMode elements.
static constexpr PixelColour PC_WHITE
White palette colour.
A number of safeguards to prevent using unsafe methods.
ClientSettings _settings_client
The current settings for this game.
Types related to global configuration settings.
void GfxClearFontSpriteCache()
Remove all encoded font sprites from the sprite cache without discarding sprite location information.
SpriteID GetMaxSpriteID()
Get a reasonable (upper bound) estimate of the maximum SpriteID used in OpenTTD; there will be no spr...
Functions to cache sprites in memory.
This file contains all sprite-related enums and defines.
static const PaletteID PALETTE_ALL_BLACK
Exchange any colour by black, needed for painting fictive tiles outside map.
static constexpr uint8_t PALETTE_WIDTH
number of bits of the sprite containing the recolour palette
static constexpr uint8_t PALETTE_MODIFIER_TRANSPARENT
when a sprite is to be displayed transparently, this bit needs to be set.
static const PaletteID PALETTE_CRASH
Recolour sprite greying of crashed vehicles.
static constexpr uint8_t PALETTE_TEXT_RECOLOUR
Set if palette is actually a magic text recolour.
static constexpr uint8_t SPRITE_WIDTH
number of bits for the sprite number
static const PaletteID PALETTE_TO_TRANSPARENT
This sets the sprite to transparent.
Definition of base types and functions in a cross-platform compatible way.
The colour translation of GRF's strings.
static constexpr PixelColour _string_colourmap[17]
Colour mapping for TextColour.
std::string GetString(StringID string)
Resolve the given StringID into a std::string with formatting but no parameters.
TextDirection _current_text_dir
Text direction of the currently selected language.
std::string_view GetEllipsis()
Get the ellipsis string for the current language.
Functions related to OTTD's strings.
StrongType::Typedef< uint32_t, struct StringIDTag, StrongType::Compare, StrongType::Integer > StringID
Numeric value that represents a string, independent of the selected language.
@ TD_RTL
Text is written right-to-left by default.
Horizontal and vertical alignment.
AlignmentH ResolveRTL() const
Resolve horizontal alignment for the current text direction.
AlignmentV v
Vertical alignment.
AlignmentH h
Horizontal alignment.
Class to backup a specific variable and restore it later.
void Restore()
Restore the variable.
Parameters related to blitting.
int skip_top
How much pixels of the source to skip on the top (based on zoom of dst).
int sprite_height
Real height of the sprite.
void * dst
Destination buffer.
int left
The left offset in the 'dst' in pixels to start drawing.
int pitch
The pitch of the destination buffer.
int sprite_width
Real width of the sprite.
int skip_left
How much pixels of the source to skip on the left (based on zoom of dst).
int height
The height in pixels that needs to be drawn to dst.
const uint8_t * remap
XXX – Temporary storage for remap array.
int width
The width in pixels that needs to be drawn to dst.
const void * sprite
Pointer to the sprite how ever the encoder stored it.
int top
The top offset in the 'dst' in pixels to start drawing.
Collection of variables for cursor-display and -animation.
bool UpdateCursorPosition(int x, int y)
Update cursor position on mouse movement.
bool fix_at
mouse is moving, but cursor is not (used for scrolling)
Point pos
logical mouse position
void UpdateCursorPositionRelative(int delta_x, int delta_y)
Update cursor position based on a relative change.
bool dirty
the rect occupied by the mouse is dirty (redraw)
Point delta
relative mouse movement in this tick
Dimensions (a width and height) of a rectangle in 2D.
value_type height
The height of the rectangle.
value_type width
The width of the rectangle.
Data about how and where to blit pixels.
Container for the text colour and some text colour related flags for drawing.
ExtendedTextColourFlags flags
The flags.
TextColour colour
The colour.
Colour for pixel/line drawing.
Data structure describing a sprite.
uint16_t width
Width of the sprite.
uint16_t height
Height of the sprite.
int16_t y_offs
Number of pixels to shift the sprite downwards.
std::byte data[]
Sprite data.
int16_t x_offs
Number of pixels to shift the sprite to the right.
Used to only draw a part of the sprite.
Data structure for an opened window.
AllWindows< false > Iterate
Iterate all windows in whatever order is easiest.
Base of all video drivers.
Functions related to (drawing on) viewports.
void ReInitAllWindows(bool zoom_changed)
Re-initialize all windows.
Window functions not directly related to making/drawing windows.
Functions, definitions and such used only by the GUI.
Functions related to zooming.
int ScaleByZoom(int value, ZoomLevel zoom)
Scale by zoom level, usually shift left (when zoom > ZoomLevel::Min) When shifting right,...
int UnScaleByZoomLower(int value, ZoomLevel zoom)
Scale by zoom level, usually shift right (when zoom > ZoomLevel::Min).
int UnScaleGUI(int value)
Short-hand to apply GUI zoom level.
int UnScaleByZoom(int value, ZoomLevel zoom)
Scale by zoom level, usually shift right (when zoom > ZoomLevel::Min) When shifting right,...
ZoomLevel
All zoom levels we know.
@ Normal
The normal zoom level.