83 #include "viewport_kdtree.h" 94 #include "table/strings.h" 99 Point _tile_fract_coords;
103 static int _viewport_sign_maxwidth = 0;
155 typedef std::vector<TileSpriteToDraw> TileSpriteToDrawVector;
156 typedef std::vector<StringSpriteToDraw> StringSpriteToDrawVector;
157 typedef std::vector<ParentSpriteToDraw> ParentSpriteToDrawVector;
158 typedef std::vector<ChildScreenSpriteToDraw> ChildScreenSpriteToDrawVector;
164 StringSpriteToDrawVector string_sprites_to_draw;
165 TileSpriteToDrawVector tile_sprites_to_draw;
166 ParentSpriteToDrawVector parent_sprites_to_draw;
168 ChildScreenSpriteToDrawVector child_screen_sprites_to_draw;
174 int foundation[FOUNDATION_PART_END];
176 int *last_foundation_child[FOUNDATION_PART_END];
177 Point foundation_offset[FOUNDATION_PART_END];
186 bool _draw_bounding_boxes =
false;
187 bool _draw_dirty_blocks =
false;
188 uint _dirty_block_colour = 0;
191 static Point MapXYZToViewport(
const ViewPort *vp,
int x,
int y,
int z)
199 void DeleteWindowViewport(
Window *w)
221 int width,
int height, uint32 follow_flags,
ZoomLevel zoom)
239 if (follow_flags & 0x80000000) {
250 pt = MapXYZToViewport(vp, x, y, GetSlopePixelZ(x, y));
258 vp->overlay =
nullptr;
265 static Point _vp_move_offs;
267 static void DoSetViewportPosition(
const Window *w,
int left,
int top,
int width,
int height)
270 if (left + width > w->
left &&
272 top + height > w->
top &&
275 if (left < w->left) {
276 DoSetViewportPosition(w, left, top, w->
left - left, height);
277 DoSetViewportPosition(w, left + (w->
left - left), top, width - (w->
left - left), height);
282 DoSetViewportPosition(w, left, top, (w->
left + w->
width - left), height);
283 DoSetViewportPosition(w, left + (w->
left + w->
width - left), top, width - (w->
left + w->
width - left), height);
288 DoSetViewportPosition(w, left, top, width, (w->
top - top));
289 DoSetViewportPosition(w, left, top + (w->
top - top), width, height - (w->
top - top));
294 DoSetViewportPosition(w, left, top, width, (w->
top + w->
height - top));
295 DoSetViewportPosition(w, left, top + (w->
top + w->
height - top), width, height - (w->
top + w->
height - top));
304 int xo = _vp_move_offs.x;
305 int yo = _vp_move_offs.y;
307 if (
abs(xo) >= width ||
abs(yo) >= height) {
309 RedrawScreenRect(left, top, left + width, top + height);
313 GfxScroll(left, top, width, height, xo, yo);
316 RedrawScreenRect(left, top, xo + left, top + height);
320 RedrawScreenRect(left + width + xo, top, left + width, top + height);
325 RedrawScreenRect(left, top, width + left, top + yo);
327 RedrawScreenRect(left, top + height + yo, width + left, top + height);
332 static void SetViewportPosition(
Window *w,
int x,
int y)
338 int left, top, width, height;
354 if (old_top == 0 && old_left == 0)
return;
356 _vp_move_offs.x = old_left;
357 _vp_move_offs.y = old_top;
369 i = left + width - _screen.width;
370 if (i >= 0) width -= i;
378 i = top + height - _screen.height;
379 if (i >= 0) height -= i;
381 if (height > 0) DoSetViewportPosition(w->
z_front, left, top, width, height);
420 Point pt = { -1, -1 };
432 static Point GetTileFromScreenXY(
int x,
int y,
int zoom_x,
int zoom_y)
446 Point GetTileBelowCursor()
448 return GetTileFromScreenXY(_cursor.
pos.x, _cursor.
pos.y, _cursor.
pos.x, _cursor.
pos.y);
458 x = ((_cursor.
pos.x - vp->
left) >> 1) + (vp->
width >> 2);
459 y = ((_cursor.
pos.y - vp->
top) >> 1) + (vp->
height >> 2);
465 return GetTileFromScreenXY(_cursor.
pos.x, _cursor.
pos.y, x + vp->
left, y + vp->
top);
501 _vd.tile_sprites_to_draw.emplace_back();
507 ts.
x = pt.x + extra_offs_x;
508 ts.
y = pt.y + extra_offs_y;
525 assert(
IsInsideMM(foundation_part, 0, FOUNDATION_PART_END));
526 assert(_vd.
foundation[foundation_part] != -1);
530 int *old_child = _vd.last_child;
533 AddChildSpriteScreen(image, pal, offs.x + extra_offs_x, offs.y + extra_offs_y,
false, sub,
false);
536 _vd.last_child = old_child;
561 AddTileSpriteToDraw(image, pal, _cur_ti->
x + x, _cur_ti->
y + y, _cur_ti->
z + z, sub, extra_offs_x * ZOOM_LVL_BASE, extra_offs_y * ZOOM_LVL_BASE);
597 default: NOT_REACHED();
624 if (pt.x + spr->
x_offs >= _vd.dpi.left + _vd.dpi.width ||
626 pt.y + spr->
y_offs >= _vd.dpi.top + _vd.dpi.height ||
659 void AddSortableSpriteToDraw(
SpriteID image,
PaletteID pal,
int x,
int y,
int w,
int h,
int dz,
int z,
bool transparent,
int bb_offset_x,
int bb_offset_y,
int bb_offset_z,
const SubSprite *sub)
661 int32 left, right, top, bottom;
676 _vd.last_child =
nullptr;
679 int tmp_left, tmp_top, tmp_x = pt.x, tmp_y = pt.y;
682 if (image == SPR_EMPTY_BOUNDING_BOX) {
683 left = tmp_left =
RemapCoords(x + w , y + bb_offset_y, z + bb_offset_z).x;
684 right =
RemapCoords(x + bb_offset_x, y + h , z + bb_offset_z).x + 1;
685 top = tmp_top =
RemapCoords(x + bb_offset_x, y + bb_offset_y, z + dz ).y;
686 bottom =
RemapCoords(x + w , y + h , z + bb_offset_z).y + 1;
689 left = tmp_left = (pt.x += spr->
x_offs);
690 right = (pt.x + spr->
width );
691 top = tmp_top = (pt.y += spr->
y_offs);
692 bottom = (pt.y + spr->
height);
695 if (_draw_bounding_boxes && (image != SPR_EMPTY_BOUNDING_BOX)) {
697 left =
min(left ,
RemapCoords(x + w , y + bb_offset_y, z + bb_offset_z).x);
698 right =
max(right ,
RemapCoords(x + bb_offset_x, y + h , z + bb_offset_z).x + 1);
699 top =
min(top ,
RemapCoords(x + bb_offset_x, y + bb_offset_y, z + dz ).y);
700 bottom =
max(bottom,
RemapCoords(x + w , y + h , z + bb_offset_z).y + 1);
704 if (left >= _vd.dpi.left + _vd.dpi.width ||
705 right <= _vd.dpi.left ||
706 top >= _vd.dpi.top + _vd.dpi.height ||
707 bottom <= _vd.dpi.top) {
711 _vd.parent_sprites_to_draw.emplace_back();
722 ps.
xmin = x + bb_offset_x;
723 ps.
xmax = x +
max(bb_offset_x, w) - 1;
725 ps.
ymin = y + bb_offset_y;
726 ps.
ymax = y +
max(bb_offset_y, h) - 1;
728 ps.
zmin = z + bb_offset_z;
729 ps.
zmax = z +
max(bb_offset_z, dz) - 1;
784 if (begin > end)
Swap(begin, end);
785 return begin <= check && check <= end;
796 int dist_a = (_thd.
size.x + _thd.
size.y);
797 int dist_b = (_thd.
size.x - _thd.
size.y);
798 int a = ((x - _thd.
pos.x) + (y - _thd.
pos.y));
799 int b = ((x - _thd.
pos.x) - (y - _thd.
pos.y));
820 if (_vd.last_child ==
nullptr)
return;
828 *_vd.last_child = (uint)_vd.child_screen_sprites_to_draw.size();
830 _vd.child_screen_sprites_to_draw.emplace_back();
835 cs.x = scale ? x * ZOOM_LVL_BASE : x;
836 cs.y = scale ? y * ZOOM_LVL_BASE : y;
844 _vd.last_child = &cs.
next;
847 static void AddStringToDraw(
int x,
int y,
StringID string, uint64 params_1, uint64 params_2, Colours colour, uint16 width)
850 _vd.string_sprites_to_draw.emplace_back();
855 ss.params[0] = params_1;
856 ss.params[1] = params_2;
898 SpriteID sel2 = SPR_HALFTILE_SELECTION_FLAT + halftile_corner;
903 sel = SPR_HALFTILE_SELECTION_DOWN;
907 sel += opposite_corner;
914 static bool IsPartOfAutoLine(
int px,
int py)
924 case HT_DIR_HU:
return px == -py || px == -py - 16;
925 case HT_DIR_HL:
return px == -py || px == -py + 16;
926 case HT_DIR_VL:
return px == py || px == py + 16;
927 case HT_DIR_VR:
return px == py || px == py - 16;
960 static const uint _lower_rail[4] = { 5U, 2U, 4U, 3U };
962 if (autorail_type != _lower_rail[halftile_corner]) {
969 offset = _AutorailTilehSprite[autorail_tileh][autorail_type];
971 image = SPR_AUTORAIL_BASE + offset;
974 image = SPR_AUTORAIL_BASE - offset;
981 enum TileHighlightType {
998 if (_viewport_highlight_station !=
nullptr) {
1000 if (_viewport_highlight_station->TileIsInCatchment(t))
return THT_BLUE;
1003 if (_viewport_highlight_town !=
nullptr) {
1006 TileHighlightType type = THT_RED;
1009 if (st->TileIsInCatchment(t))
return THT_BLUE;
1033 case THT_NONE:
break;
1048 if (_town_local_authority_kdtree.
Count() == 0)
return;
1114 if ((halftile_corner == CORNER_W) || (halftile_corner == CORNER_E)) z +=
TILE_HEIGHT;
1115 if (halftile_corner != CORNER_S) {
1126 }
else if (IsPartOfAutoLine(ti->
x, ti->
y)) {
1144 if (!is_redsq && (tht == THT_NONE || tht == THT_RED) && _thd.
outersize.x > 0 &&
1170 assert(_vd.dpi.top <= _vd.dpi.top + _vd.dpi.height);
1171 assert(_vd.dpi.left <= _vd.dpi.left + _vd.dpi.width);
1189 int left_column = (upper_left.y - upper_left.x) / (
int)
TILE_SIZE - 2;
1190 int right_column = (upper_right.y - upper_right.x) / (
int)
TILE_SIZE + 2;
1198 int row = (upper_left.x + upper_left.y) / (
int)
TILE_SIZE - 2;
1199 bool last_row =
false;
1200 for (; !last_row; row++) {
1202 for (
int column = left_column; column <= right_column; column++) {
1204 if ((row + column) % 2 != 0)
continue;
1207 tilecoord.x = (row - column) / 2;
1208 tilecoord.y = (row + column) / 2;
1209 assert(column == tilecoord.y - tilecoord.x);
1210 assert(row == tilecoord.y + tilecoord.x);
1214 _cur_ti = &tile_info;
1220 tile_info.
tile =
TileXY(tilecoord.x, tilecoord.y);
1244 int min_visible_height = viewport_y - (_vd.dpi.top + _vd.dpi.height);
1245 bool tile_visible = min_visible_height <= 0;
1264 if ((tilecoord.x <= 0 || tilecoord.y <= 0) && min_visible_height < potential_bridge_height +
MAX_TILE_EXTENT_TOP) last_row =
false;
1294 bool small = dpi->zoom >= small_from;
1296 int left = dpi->left;
1298 int right = left + dpi->width;
1299 int bottom = top + dpi->height;
1304 if (bottom < sign->top ||
1305 top > sign->
top + sign_height ||
1306 right < sign->center - sign_half_width ||
1307 left > sign->
center + sign_half_width) {
1312 AddStringToDraw(sign->
center - sign_half_width, sign->
top, string_normal, params_1, params_2, colour, sign->
width_normal);
1314 int shadow_offset = 0;
1315 if (string_small_shadow != STR_NULL) {
1317 AddStringToDraw(sign->
center - sign_half_width + shadow_offset, sign->
top, string_small_shadow, params_1, params_2, INVALID_COLOUR, sign->
width_small);
1319 AddStringToDraw(sign->
center - sign_half_width, sign->
top - shadow_offset, string_small, params_1, params_2,
1328 const int max_tw = _viewport_sign_maxwidth / 2 + 1;
1333 r.right += expand_x;
1335 r.bottom += expand_y;
1342 Rect search_rect{ dpi->left, dpi->top, dpi->left + dpi->width, dpi->top + dpi->height };
1343 search_rect = ExpandRectWithViewportSignMargins(search_rect, dpi->zoom);
1355 std::vector<const BaseStation *> stations;
1356 std::vector<const Town *> towns;
1357 std::vector<const Sign *> signs;
1360 switch (item.type) {
1361 case ViewportSignKdtreeItem::VKI_STATION:
1362 if (!show_stations) break;
1363 st = BaseStation::Get(item.id.station);
1366 if (!show_competitors && _local_company != st->owner && st->owner != OWNER_NONE) break;
1368 stations.push_back(st);
1371 case ViewportSignKdtreeItem::VKI_WAYPOINT:
1372 if (!show_waypoints) break;
1373 st = BaseStation::Get(item.id.station);
1376 if (!show_competitors && _local_company != st->owner && st->owner != OWNER_NONE) break;
1378 stations.push_back(st);
1381 case ViewportSignKdtreeItem::VKI_TOWN:
1382 if (!show_towns) break;
1383 towns.push_back(Town::Get(item.id.town));
1386 case ViewportSignKdtreeItem::VKI_SIGN:
1387 if (!show_signs) break;
1388 si = Sign::Get(item.id.sign);
1393 if (!show_competitors && _local_company != si->owner && si->owner != OWNER_DEITY) break;
1395 signs.push_back(si);
1405 for (
const auto *t : towns) {
1408 STR_VIEWPORT_TOWN_TINY_WHITE, STR_VIEWPORT_TOWN_TINY_BLACK,
1409 t->index, t->cache.population);
1412 for (
const auto *si : signs) {
1419 for (
const auto *st : stations) {
1423 STR_VIEWPORT_STATION, STR_VIEWPORT_STATION + 1, STR_NULL,
1428 STR_VIEWPORT_WAYPOINT, STR_VIEWPORT_WAYPOINT + 1, STR_NULL,
1444 if (this->width_normal != 0) this->MarkDirty();
1450 GetString(buffer, str,
lastof(buffer));
1452 this->center = center;
1455 if (str_small != STR_NULL) {
1456 GetString(buffer, str_small,
lastof(buffer));
1475 zoomlevels[zoom].left = this->center -
ScaleByZoom(this->width_normal / 2 + 1, zoom);
1476 zoomlevels[zoom].top = this->top -
ScaleByZoom(1, zoom);
1477 zoomlevels[zoom].right = this->center +
ScaleByZoom(this->width_normal / 2 + 1, zoom);
1482 FOR_ALL_WINDOWS_FROM_BACK(w) {
1484 if (vp !=
nullptr && vp->
zoom <= maxzoom) {
1485 assert(vp->
width != 0);
1492 static void ViewportDrawTileSprites(
const TileSpriteToDrawVector *tstdv)
1508 auto psdvend = psdv->end();
1509 auto psd = psdv->begin();
1510 while (psd != psdvend) {
1520 for (
auto psd2 = psd + 1; psd2 != psdvend; psd2++) {
1555 for (
auto psd3 = psd2; psd3 > psd; psd3--) {
1556 *psd3 = *(psd3 - 1);
1563 static void ViewportDrawParentSprites(
const ParentSpriteToSortVector *psd,
const ChildScreenSpriteToDrawVector *csstdv)
1566 if (ps->image != SPR_EMPTY_BOUNDING_BOX)
DrawSpriteViewport(ps->image, ps->pal, ps->x, ps->y, ps->sub);
1568 int child_idx = ps->first_child;
1569 while (child_idx >= 0) {
1571 child_idx = cs->
next;
1590 pt2.x - pt1.x, pt2.y - pt1.y,
1591 pt3.x - pt1.x, pt3.y - pt1.y,
1592 pt4.x - pt1.x, pt4.y - pt1.y);
1611 byte bo =
UnScaleByZoom(dpi->left + dpi->top, dpi->zoom) & 1;
1613 for (
int i = (bo ^= 1); i < right; i += 2) blitter->
SetPixel(dst, i, 0, (uint8)colour);
1614 dst = blitter->
MoveTo(dst, 0, 1);
1615 }
while (--bottom > 0);
1618 static void ViewportDrawStrings(
ZoomLevel zoom,
const StringSpriteToDrawVector *sstdv)
1622 bool small =
HasBit(ss.width, 15);
1623 int w =
GB(ss.width, 0, 15);
1631 if (ss.colour != INVALID_COLOUR) {
1644 x, y, x + w, y + h, ss.colour,
1654 void ViewportDoDraw(
const ViewPort *vp,
int left,
int top,
int right,
int bottom)
1657 _cur_dpi = &_vd.dpi;
1659 _vd.dpi.zoom = vp->
zoom;
1664 _vd.dpi.width = (right - left) & mask;
1665 _vd.dpi.height = (bottom - top) & mask;
1666 _vd.dpi.left = left & mask;
1667 _vd.dpi.top = top & mask;
1668 _vd.dpi.pitch = old_dpi->pitch;
1669 _vd.last_child =
nullptr;
1679 ViewportAddKdtreeSigns(&_vd.dpi);
1681 DrawTextEffects(&_vd.dpi);
1683 if (_vd.tile_sprites_to_draw.size() != 0) ViewportDrawTileSprites(&_vd.tile_sprites_to_draw);
1685 for (
auto &psd : _vd.parent_sprites_to_draw) {
1706 vp->overlay->
Draw(&dp);
1709 if (_vd.string_sprites_to_draw.size() != 0) {
1713 ViewportDrawStrings(zoom, &_vd.string_sprites_to_draw);
1718 _vd.string_sprites_to_draw.clear();
1719 _vd.tile_sprites_to_draw.clear();
1720 _vd.parent_sprites_to_draw.clear();
1722 _vd.child_screen_sprites_to_draw.clear();
1732 if ((bottom - top) > (right - left)) {
1733 int t = (top + bottom) >> 1;
1737 int t = (left + right) >> 1;
1751 static inline void ViewportDraw(
const ViewPort *vp,
int left,
int top,
int right,
int bottom)
1753 if (right <= vp->left || bottom <= vp->top)
return;
1755 if (left >= vp->
left + vp->
width)
return;
1757 if (left < vp->left) left = vp->
left;
1760 if (top >= vp->
top + vp->
height)
return;
1762 if (top < vp->top) top = vp->
top;
1777 dpi->left += this->left;
1778 dpi->top += this->top;
1780 ViewportDraw(this->viewport, dpi->left, dpi->top, dpi->left + dpi->width, dpi->top + dpi->height);
1782 dpi->left -= this->left;
1783 dpi->top -= this->top;
1830 SetViewportPosition(w, pt.x, pt.y);
1838 bool update_overlay =
false;
1839 if (delta_x != 0 || delta_y != 0) {
1856 if (update_overlay) RebuildViewportOverlay(w);
1872 right += (1 << vp->
zoom) - 1;
1873 bottom += (1 << vp->
zoom) - 1;
1876 if (right <= 0)
return;
1879 if (bottom <= 0)
return;
1908 FOR_ALL_WINDOWS_FROM_BACK(w) {
1910 if (vp !=
nullptr) {
1911 assert(vp->
width != 0);
1917 void ConstrainAllViewportsZoom()
1920 FOR_ALL_WINDOWS_FROM_FRONT(w) {
1921 if (w->
viewport ==
nullptr)
continue;
1957 int x_size = _thd.
size.x;
1958 int y_size = _thd.
size.y;
1961 int x_start = _thd.
pos.x;
1962 int y_start = _thd.
pos.y;
1966 x_start += _thd.
offs.x;
1968 y_start += _thd.
offs.y;
1974 assert(x_size >= 0);
1975 assert(y_size >= 0);
1984 assert((x_end | y_end | x_start | y_start) %
TILE_SIZE == 0);
2005 int top_y = y_start;
2026 static const int OVERLAY_WIDTH = 4 * ZOOM_LVL_BASE;
2032 if (top_x != x_start) {
2039 if (bot_y != y_end) {
2044 }
while (bot_x >= top_x);
2047 int a_size = x_size + y_size, b_size = x_size - y_size;
2052 for (
int a = -interval_a; a != a_size + interval_a; a += interval_a) {
2053 for (
int b = -interval_b; b != b_size + interval_b; b += interval_b) {
2066 void SetSelectionRed(
bool b)
2086 return y >= sign->
top && y < sign->
top + sign_height &&
2087 x >= sign->
center - sign_half_width && x < sign->
center + sign_half_width;
2100 if (_game_mode == GM_MENU)
return false;
2105 Rect search_rect{ x - 1, y - 1, x + 1, y + 1 };
2106 search_rect = ExpandRectWithViewportSignMargins(search_rect, vp->
zoom);
2116 Town *t =
nullptr, *last_t =
nullptr;
2117 Sign *si =
nullptr, *last_si =
nullptr;
2121 switch (item.type) {
2122 case ViewportSignKdtreeItem::VKI_STATION:
2123 if (!show_stations) break;
2124 st = BaseStation::Get(item.id.station);
2125 if (!show_competitors && _local_company != st->owner && st->owner != OWNER_NONE) break;
2126 if (CheckClickOnViewportSign(vp, x, y, &st->sign)) last_st = st;
2129 case ViewportSignKdtreeItem::VKI_WAYPOINT:
2130 if (!show_waypoints) break;
2131 st = BaseStation::Get(item.id.station);
2132 if (!show_competitors && _local_company != st->owner && st->owner != OWNER_NONE) break;
2133 if (CheckClickOnViewportSign(vp, x, y, &st->sign)) last_st = st;
2136 case ViewportSignKdtreeItem::VKI_TOWN:
2137 if (!show_towns) break;
2138 t = Town::Get(item.id.town);
2139 if (CheckClickOnViewportSign(vp, x, y, &t->cache.sign)) last_t = t;
2142 case ViewportSignKdtreeItem::VKI_SIGN:
2143 if (!show_signs) break;
2144 si = Sign::Get(item.id.sign);
2145 if (!show_competitors && _local_company != si->owner && si->owner != OWNER_DEITY) break;
2146 if (CheckClickOnViewportSign(vp, x, y, &si->sign)) last_si = si;
2155 if (last_st !=
nullptr) {
2162 }
else if (last_t !=
nullptr) {
2163 ShowTownViewWindow(last_t->index);
2165 }
else if (last_si !=
nullptr) {
2177 item.type = VKI_STATION;
2178 item.id.station = id;
2186 _viewport_sign_maxwidth = max<int>(_viewport_sign_maxwidth, st->
sign.
width_normal);
2194 item.type = VKI_WAYPOINT;
2195 item.id.station = id;
2203 _viewport_sign_maxwidth = max<int>(_viewport_sign_maxwidth, st->
sign.
width_normal);
2211 item.type = VKI_TOWN;
2228 item.type = VKI_SIGN;
2233 item.center = sign->sign.
center;
2234 item.top = sign->sign.
top;
2237 _viewport_sign_maxwidth = max<int>(_viewport_sign_maxwidth, sign->sign.
width_normal);
2242 void RebuildViewportKdtree()
2245 _viewport_sign_maxwidth = 0;
2247 std::vector<ViewportSignKdtreeItem> items;
2251 if (st->sign.kdtree_valid) items.push_back(ViewportSignKdtreeItem::MakeStation(st->index));
2255 if (wp->sign.kdtree_valid) items.push_back(ViewportSignKdtreeItem::MakeWaypoint(wp->index));
2259 if (town->cache.sign.kdtree_valid) items.push_back(ViewportSignKdtreeItem::MakeTown(town->index));
2263 if (sign->sign.kdtree_valid) items.push_back(ViewportSignKdtreeItem::MakeSign(sign->index));
2266 _viewport_sign_kdtree.
Build(items.begin(), items.end());
2270 static bool CheckClickOnLandscape(
const ViewPort *vp,
int x,
int y)
2274 if (pt.x != -1)
return ClickTile(
TileVirtXY(pt.x, pt.y));
2278 static void PlaceObject()
2283 pt = GetTileBelowCursor();
2284 if (pt.x == -1)
return;
2299 bool HandleViewportClicked(
const ViewPort *vp,
int x,
int y)
2314 bool result = CheckClickOnLandscape(vp, x, y);
2331 void RebuildViewportOverlay(
Window *w)
2333 if (w->
viewport->overlay !=
nullptr &&
2356 z = GetSlopePixelZ(x, y);
2370 RebuildViewportOverlay(w);
2431 void SetTileSelectBigSize(
int ox,
int oy,
int sx,
int sy)
2452 this->new_pos.x = 0;
2453 this->new_pos.y = 0;
2491 bool new_diagonal =
false;
2503 new_diagonal =
true;
2505 if (x1 >= x2)
Swap(x1, x2);
2506 if (y1 >= y2)
Swap(y1, y2);
2512 if (!new_diagonal) {
2519 Point pt = GetTileBelowCursor();
2551 default: NOT_REACHED();
2599 static void HideMeasurementTooltips()
2638 void VpSetPlaceSizingLimit(
int limit)
2662 HideMeasurementTooltips();
2666 static void VpStartPreSizing()
2678 int fxpy = _tile_fract_coords.x + _tile_fract_coords.y;
2680 int fxmy = _tile_fract_coords.x - _tile_fract_coords.y;
2684 default: NOT_REACHED();
2686 if (fxpy >= 20 && sxpy <= 12)
return HT_DIR_HL;
2687 if (fxmy < -3 && sxmy > 3)
return HT_DIR_VR;
2691 if (fxmy > 3 && sxmy < -3)
return HT_DIR_VL;
2692 if (fxpy <= 12 && sxpy >= 20)
return HT_DIR_HU;
2696 if (fxmy > 3 && sxmy < -3)
return HT_DIR_VL;
2697 if (fxpy >= 20 && sxpy <= 12)
return HT_DIR_HL;
2701 if (fxmy < -3 && sxmy > 3)
return HT_DIR_VR;
2702 if (fxpy <= 12 && sxpy >= 20)
return HT_DIR_HU;
2722 uint start_x =
TileX(start_tile);
2723 uint start_y =
TileY(start_tile);
2724 uint end_x =
TileX(end_tile);
2725 uint end_y =
TileY(end_tile);
2729 case HT_LINE:
return (end_x > start_x || (end_x == start_x && end_y > start_y));
2732 case HT_POINT:
return (end_x != start_x && end_y < start_y);
2733 default: NOT_REACHED();
2759 if (start_tile == end_tile)
return 0;
2760 if (swap)
Swap(start_tile, end_tile);
2771 byte style_t = (byte)(
TileX(end_tile) >
TileX(start_tile));
2786 {1, 0}, {1, 1}, {0, 1}, {1, 1},
2787 {1, 0}, {0, 0}, {1, 0}, {1, 1},
2788 {1, 0}, {1, 1}, {0, 1}, {1, 1},
2790 {0, 1}, {0, 0}, {1, 0}, {0, 0},
2791 {0, 1}, {0, 0}, {1, 1}, {0, 1},
2792 {1, 0}, {0, 0}, {0, 0}, {0, 1},
2802 if (swap && distance == 0) style = flip_style_direction[style];
2805 byte style_t = style * 2;
2806 assert(style_t <
lengthof(heightdiff_line_by_dir) - 13);
2813 if (distance == 0) style_t = flip_style_direction[style] * 2;
2814 assert(style_t <
lengthof(heightdiff_line_by_dir) - 13);
2822 if (swap)
Swap(h0, h1);
2826 static const StringID measure_strings_length[] = {STR_NULL, STR_MEASURE_LENGTH, STR_MEASURE_LENGTH_HEIGHTDIFF};
2836 if (test >= 0)
return;
2838 other += mult * test;
2851 if (test <= max)
return;
2853 other += mult * (test -
max);
2896 int offset = (raw_dx - raw_dy) / 2;
2931 int offset = (raw_dx + raw_dy + (int)
TILE_SIZE) / 2;
2980 }
else if (w > h * 2) {
2983 }
else if (h > w * 2) {
2997 }
else if (d >= 0) {
3008 }
else if (d >= 0) {
3021 }
else if (d >= 0) {
3032 }
else if (d >= 0) {
3050 if (distance != 1) {
3056 distance =
CeilDiv(distance, 2);
3059 params[index++] = distance;
3060 if (heightdiff != 0) params[index++] = heightdiff;
3109 if (
abs(sy - y) <
abs(sx - x)) {
3116 goto calc_heightdiff_single_direction;
3125 goto calc_heightdiff_single_direction;
3135 calc_heightdiff_single_direction:;
3137 x = sx +
Clamp(x - sx, -limit, limit);
3138 y = sy +
Clamp(y - sy, -limit, limit);
3147 if (distance != 1) {
3155 params[index++] = distance;
3156 if (heightdiff != 0) params[index++] = heightdiff;
3165 x = sx +
Clamp(x - sx, -limit, limit);
3166 y = sy +
Clamp(y - sy, -limit, limit);
3171 static const StringID measure_strings_area[] = {
3172 STR_NULL, STR_NULL, STR_MEASURE_AREA, STR_MEASURE_AREA_HEIGHTDIFF
3198 int a_max = dist_x + dist_y;
3199 int b_max = dist_y - dist_x;
3203 a_max =
abs(a_max + (a_max > 0 ? 2 : -2)) / 2;
3204 b_max =
abs(b_max + (b_max > 0 ? 2 : -2)) / 2;
3210 if (a_max != 1 || b_max != 1) {
3217 }
else if (dy == 1) {
3222 if (dx != 1 || dy != 1) {
3225 params[index++] = dx - (style &
HT_POINT ? 1 : 0);
3226 params[index++] = dy - (style &
HT_POINT ? 1 : 0);
3227 if (heightdiff != 0) params[index++] = heightdiff;
3234 default: NOT_REACHED();
3277 HideMeasurementTooltips();
3318 HideMeasurementTooltips();
3379 { &ViewportSortParentSpritesSSE41Checker, &ViewportSortParentSpritesSSE41 },
3387 for (uint i = 0; i <
lengthof(_vp_sprite_sorters); i++) {
3388 if (_vp_sprite_sorters[i].fct_checker()) {
3389 _vp_sprite_sorter = _vp_sprite_sorters[i].
fct_sorter;
3393 assert(_vp_sprite_sorter !=
nullptr);
3429 static void MarkCatchmentTilesDirty()
3459 MarkCatchmentTilesDirty();
3462 MarkCatchmentTilesDirty();
3464 MarkCatchmentTilesDirty();
EventState
State of handling an event.
void ViewportAddVehicles(DrawPixelInfo *dpi)
Add the vehicle sprites that should be drawn at a part of the screen.
bool DoZoomInOutWindow(ZoomStateChange how, Window *w)
Zooms a viewport in a window in or out.
Functions related to OTTD's strings.
static TileType GetTileType(TileIndex tile)
Get the tiletype of a given tile.
ViewportDragDropSelectionProcess
Drag and drop selection process, or, what to do with an area of land when you've selected it...
Owner
Enum for all companies/owners.
bool measure_tooltip
show a permanent tooltip when dragging tools
static bool IsHalftileSlope(Slope s)
Checks for non-continuous slope on halftile foundations.
Iterator to iterate over all tiles belonging to a bitmaptilearea.
static void DrawAutorailSelection(const TileInfo *ti, uint autorail_type)
Draws autorail highlights.
static const PaletteID PALETTE_SEL_TILE_RED
makes a square red. is used when removing rails or other stuff
static void Swap(T &a, T &b)
Type safe swap operation.
the north corner of the tile is raised
Corner
Enumeration of tile corners.
uint32 PaletteID
The number of the palette.
static const uint TILE_PIXELS
Pixel distance between tile columns/rows in #ZOOM_LVL_BASE.
WindowNumber window_number
The WindowNumber of the window that is responsible for the selection mode.
static uint MapSizeX()
Get the size of the map along the X.
static const int MAX_TILE_EXTENT_RIGHT
Maximum right extent of tile relative to north corner.
GameSettings _settings_game
Game settings of a running game or the scenario editor.
bool IsDraggingDiagonal()
Is the user dragging a 'diagonal rectangle'?
int32 zmin
minimal world Z coordinate of bounding box
Definition of stuff that is very close to a company, like the company struct itself.
int32 zmax
maximal world Z coordinate of bounding box
static const PaletteID PALETTE_TO_TRANSPARENT
This sets the sprite to transparent.
Window * FindWindowFromPt(int x, int y)
Do a search for a window at specific coordinates.
void ShowWaypointWindow(const Waypoint *wp)
Show the window for the given waypoint.
int virtual_left
Virtual left coordinate.
int32 top
minimal screen Y coordinate of sprite (= y + sprite->y_offs), reference point for child sprites ...
void InitializeWindowViewport(Window *w, int x, int y, int width, int height, uint32 follow_flags, ZoomLevel zoom)
Initialize viewport of the window for use.
static bool SwapDirection(HighLightStyle style, TileIndex start_tile, TileIndex end_tile)
Check if the direction of start and end tile should be swapped based on the dragging-style.
Data about how and where to blit pixels.
static uint MapSizeY()
Get the size of the map along the Y.
Horizontally center the text.
Tile information, used while rendering the tile.
Sprite combining will start with the next unclipped sprite.
SpriteCombineMode
Mode of "sprite combining".
void SetWidgetDisabledState(byte widget_index, bool disab_stat)
Sets the enabled/disabled status of a widget.
Point pos
Location, in tile "units", of the northern tile of the selected area.
Point pos
logical mouse position
void SetWindowDirty(WindowClass cls, WindowNumber number)
Mark window as dirty (in need of repainting)
area of land of limited size
void(* VpSpriteSorter)(ParentSpriteToSortVector *psd)
Type for the actual viewport sprite sorter.
The mask to for the main sprite.
static const PaletteID PALETTE_TILE_RED_PULSATING
pulsating red tile drawn if you try to build a wrong tunnel or raise/lower land where it is not possi...
uint32 GetCompanyMask()
Get a bitmask of the currently shown companies.
byte _display_opt
What do we want to draw/do?
EconomySettings economy
settings to change the economy
int left
x position of left edge of the window
SpecialMouseMode _special_mouse_mode
Mode of the mouse.
bool VehicleClicked(const Vehicle *v)
Dispatch a "vehicle selected" event if any window waits for it.
Zoom out (get helicopter view).
static int GetTilePixelZ(TileIndex tile)
Get bottom height of the tile.
int height
Screen height of the viewport.
static Titem * Get(size_t index)
Returns Titem with given index.
int32 y
screen Y coordinate of sprite
Declarations for accessing the k-d tree of towns.
void HandleZoomMessage(Window *w, const ViewPort *vp, byte widget_zoom_in, byte widget_zoom_out)
Update the status of the zoom-buttons according to the zoom-level of the viewport.
static Point RemapCoords(int x, int y, int z)
Map 3D world or tile coordinate to equivalent 2D coordinate as used in the viewports and smallmap...
VpSorterChecker fct_checker
The check function.
TileType
The different types of tiles.
void SetWidgetDirty(byte widget_index) const
Invalidate a widget, i.e.
static int UnScaleByZoomLower(int value, ZoomLevel zoom)
Scale by zoom level, usually shift right (when zoom > ZOOM_LVL_NORMAL)
int next
next child to draw (-1 at the end)
static T SetBit(T &x, const uint8 y)
Set a bit in a variable.
Window * FindWindowById(WindowClass cls, WindowNumber number)
Find a window by its class and window number.
The passed event is not handled.
byte _colour_gradient[COLOUR_END][8]
All 16 colour gradients 8 colours per gradient from darkest (0) to lightest (7)
void SetTileSelectSize(int w, int h)
Highlight w by h tiles at the cursor.
static int UnScaleByZoom(int value, ZoomLevel zoom)
Scale by zoom level, usually shift right (when zoom > ZOOM_LVL_NORMAL) When shifting right...
static const CommandCost CMD_ERROR
Define a default return value for a failed command.
Data structure describing a sprite.
Slope tileh
Slope of the tile.
Sprite combining is active. AddSortableSpriteToDraw outputs child sprites.
Types for recording game performance data.
Drag only in X axis with limited size.
static const AnimCursor *const _animcursors[]
This is an array of pointers to all the animated cursor definitions we have above.
similar to VMP_RAILDIRS, but with different cursor
void GuiShowTooltips(Window *parent, StringID str, uint paramcount, const uint64 params[], TooltipCloseCondition close_tooltip)
Shows a tooltip.
Slope GetTilePixelSlopeOutsideMap(int x, int y, int *h)
Return the slope of a given tile, also for tiles outside the map (virtual "black" tiles)...
static void CheckUnderflow(int &test, int &other, int mult)
Check for underflowing the map.
Point size
Size, in tile "units", of the white/red selection area.
virtual void SetPixel(void *video, int x, int y, uint8 colour)=0
Draw a pixel with a given colour on the video-buffer.
bool population_in_label
show the population of a town in his label?
Drag only in Y axis with limited size.
Functions related to vehicles.
static const int MAX_TILE_EXTENT_LEFT
Maximum left extent of tile relative to north corner.
int virtual_height
height << zoom
Point new_size
New value for size; used to determine whether to redraw the selection.
static void AddTileSpriteToDraw(SpriteID image, PaletteID pal, int32 x, int32 y, int z, const SubSprite *sub=nullptr, int extra_offs_x=0, int extra_offs_y=0)
Schedules a tile sprite for drawing.
static uint TileX(TileIndex tile)
Get the X component of a tile.
Point new_pos
New value for pos; used to determine whether to redraw the selection.
int top
y position of top edge of the window
static bool IsExpected(const BaseStation *st)
Helper for checking whether the given station is of this type.
static int ScaleByZoom(int value, ZoomLevel zoom)
Scale by zoom level, usually shift left (when zoom > ZOOM_LVL_NORMAL) When shifting right...
Tindex index
Index of this pool item.
int foundation[FOUNDATION_PART_END]
Foundation sprites (index into parent_sprites_to_draw).
static const int DRAW_STRING_BUFFER
Size of the buffer used for drawing strings.
static bool IsSteepSlope(Slope s)
Checks if a slope is steep.
bool show_zone
NOSAVE: mark town to show the local authority zone in the viewports.
Display signs, station names and waypoint names of opponent companies. Buoys and oilrig-stations are ...
Zoom in (get more detailed view).
Representation of a waypoint.
void SetViewportCatchmentTown(const Town *t, bool sel)
Select or deselect town for coverage area highlight.
Maximum number of sprites that can be loaded at a given time.
#define lastof(x)
Get the last element of an fixed size array.
void FindContained(CoordT x1, CoordT y1, CoordT x2, CoordT y2, Outputter outputter) const
Find all items contained within the given rectangle.
SpriteCombineMode combine_sprites
Current mode of "sprite combining".
T FindNearest(CoordT x, CoordT y) const
Find the element closest to given coordinate, in Manhattan distance.
Second part (halftile foundation)
static Corner GetHalftileSlopeCorner(Slope s)
Returns the leveled halftile of a halftile slope.
byte dist_local_authority
distance for town local authority, default 20
static Pool::IterateWrapper< Station > Iterate(size_t from=0)
Returns an iterable ensemble of all valid stations of type T.
WindowClass
Window classes.
ParentSpriteToSortVector parent_sprites_to_sort
Parent sprite pointer array used for sorting.
static int DivAwayFromZero(int a, uint b)
Computes (a / b) rounded away from zero.
virtual void OnPlaceDrag(ViewportPlaceMethod select_method, ViewportDragDropSelectionProcess select_proc, Point pt)
The user is dragging over the map when the tile highlight mode has been set.
virtual void OnPlaceObjectAbort()
The user cancelled a tile highlight mode that has been set.
Common return value for all commands.
How all blitters should look like.
ClientID
'Unique' identifier to be given to clients
static Slope SlopeWithOneCornerRaised(Corner corner)
Returns the slope with a specific corner raised.
static const VehicleID INVALID_VEHICLE
Constant representing a non-existing vehicle.
void StartSpriteCombine()
Starts a block of sprites, which are "combined" into a single bounding box.
Functions related to signs.
void UpdatePosition(int center, int top, StringID str, StringID str_small=STR_NULL)
Update the position of the viewport sign.
static T max(const T a, const T b)
Returns the maximum of two values.
Presizing mode (docks, tunnels).
Functions related to the vehicle's GUIs.
Window * GetCallbackWnd()
Get the window that started the current highlighting.
static const uint TILE_SIZE
Tile size in world coordinates.
FoundationPart foundation_part
Currently active foundation for ground sprite drawing.
void MarkDirty(ZoomLevel maxzoom=ZOOM_LVL_MAX) const
Mark the sign dirty in all viewports.
int32 x
screen X coordinate of sprite
Highlight/sprite information for autorail.
CommandCost CmdScrollViewport(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
Scroll players main viewport.
HighLightStyle place_mode
Method which is used to place the selection.
Functions, definitions and such used only by the GUI.
TileIndex GetNorthernBridgeEnd(TileIndex t)
Finds the northern end of a bridge starting at a middle tile.
static Waypoint * From(BaseStation *st)
Converts a BaseStation to SpecializedStation with type checking.
ViewportScrollTarget
Target of the viewport scrolling GS method.
static bool IsInsideBS(const T x, const size_t base, const size_t size)
Checks if a value is between a window started at some base point.
Point foundation_offset[FOUNDATION_PART_END]
Pixel offset for ground sprites on the foundations.
Functions related to (drawing on) viewports.
void Draw(const DrawPixelInfo *dpi)
Draw the linkgraph overlay or some part of it, in the area given.
Declaration of linkgraph overlay GUI.
Data structure for an opened window.
bool _ctrl_pressed
Is Ctrl pressed?
Data structure storing rendering information.
static bool IsValidTile(TileIndex tile)
Checks if a tile is valid.
void EndSpriteCombine()
Terminates a block of sprites started by StartSpriteCombine.
static bool IsInsideMM(const T x, const size_t min, const size_t max)
Checks if a value is in an interval.
static bool IsBridgeAbove(TileIndex t)
checks if a bridge is set above the ground of this tile
Point TranslateXYToTileCoord(const ViewPort *vp, int x, int y, bool clamp_to_map)
Translate screen coordinate in a viewport to underlying tile coordinate.
dragging items in the depot windows
static HighLightStyle GetAutorailHT(int x, int y)
returns the best autorail highlight type from map coordinates
Point selstart
The location where the dragging started.
Town * ClosestTownFromTile(TileIndex tile, uint threshold)
Return the town closest (in distance or ownership) to a given tile, within a given threshold...
Main window; Window numbers:
byte sizelimit
Whether the selection is limited in length, and what the maximum length is.
First part (normal foundation or no foundation)
Point selend
The location where the drag currently ends.
uint x
X position of the tile in unit coordinates.
The tile has no ownership.
TileIndex xy
town center tile
Every AddSortableSpriteToDraw start its own bounding box.
static bool IsTileType(TileIndex tile, TileType type)
Checks if a tile is a given tiletype.
int16 y_offs
Number of pixels to shift the sprite downwards.
TileIndex tile
Tile index.
UnitID unitnumber
unit number, for display purposes only
#define FONT_HEIGHT_SMALL
Height of characters in the small (FS_SMALL) font.
int32 ymin
minimal world Y coordinate of bounding box
int32 first_child
the first child to draw.
void ResetObjectToPlace()
Reset the cursor and mouse mode handling back to default (normal cursor, only clicking in windows)...
static T Align(const T x, uint n)
Return the smallest multiple of n equal or greater than x.
const Town * _viewport_highlight_town
Currently selected town for coverage area highlight.
int32 top
The top of the sign.
void SetRedErrorSquare(TileIndex tile)
Set a tile to display a red error square.
size_t Count() const
Get number of elements stored in tree.
Tooltip window; Window numbers:
void VpStartPlaceSizing(TileIndex tile, ViewportPlaceMethod method, ViewportDragDropSelectionProcess process)
highlighting tiles while only going over them with the mouse
void SetObjectToPlace(CursorID icon, PaletteID pal, HighLightStyle mode, WindowClass window_class, WindowNumber window_num)
Change the cursor and mouse click/drag handling to a mode for performing special operations like tile...
int32 x
screen X coordinate of sprite
void MarkAllViewportsDirty(int left, int top, int right, int bottom)
Mark all viewports that display an area as dirty (in need of repaint).
Point offs
Offset, in tile "units", for the blue coverage area from the selected area's northern tile...
static TownID GetTownIndex(TileIndex t)
Get the index of which town this house/street is attached to.
uint32 VehicleID
The type all our vehicle IDs have.
ViewportPlaceMethod
Viewport place method (type of highlighted area and placed objects)
void DrawSpriteViewport(SpriteID img, PaletteID pal, int x, int y, const SubSprite *sub)
Draw a sprite in a viewport.
DoCommandFlag
List of flags for a command.
bool _left_button_down
Is left mouse button pressed?
#define FONT_HEIGHT_NORMAL
Height of characters in the normal (FS_NORMAL) font.
ClientID _network_own_client_id
Our client identifier.
ClientSettings _settings_client
The current settings for this game.
static const CursorID ANIMCURSOR_FLAG
Flag for saying a cursor sprite is an animated cursor.
static void ShowMeasurementTooltips(StringID str, uint paramcount, const uint64 params[], TooltipCloseCondition close_cond=TCC_NONE)
Displays the measurement tooltips when selecting multiple tiles.
static ViewportSSCSS _vp_sprite_sorters[]
List of sorters ordered from best to worst.
static void ViewportDrawChk(const ViewPort *vp, int left, int top, int right, int bottom)
Make sure we don't draw a too big area at a time.
Definition of base types and functions in a cross-platform compatible way.
Location information about a sign as seen on the viewport.
static void ViewportDrawBoundingBoxes(const ParentSpriteToSortVector *psd)
Draws the bounding boxes of all ParentSprites.
static void ViewportSortParentSprites(ParentSpriteToSortVector *psdv)
Sort parent sprites pointer array.
A number of safeguards to prevent using unsafe methods.
StationList stations_near
NOSAVE: List of nearby stations.
TextColour
Colour of the strings, see _string_colourmap in table/string_colours.h or docs/ottd-colourtext-palett...
static void SetSelectionTilesDirty()
Marks the selected tiles as dirty.
static void CheckOverflow(int &test, int &other, int max, int mult)
Check for overflowing the map.
rectangle (stations, depots, ...)
uint y
Y position of the tile in unit coordinates.
int32 y
screen Y coordinate of sprite
static uint CeilDiv(uint a, uint b)
Computes ceil(a / b) for non-negative a and b.
ViewportPlaceMethod select_method
The method which governs how tiles are selected.
static void HighlightTownLocalAuthorityTiles(const TileInfo *ti)
Highlights tiles insede local authority of selected towns.
void StartStopVehicle(const Vehicle *v, bool texteffect)
Executes CMD_START_STOP_VEHICLE for given vehicle.
Data structure for a window viewport.
All zoomlevels below or equal to this, will result in details on the screen, like road-work...
static Slope GetTilePixelSlope(TileIndex tile, int *h)
Return the slope of a given tile.
static const uint TILE_HEIGHT
Height of a height level in world coordinate AND in pixels in #ZOOM_LVL_BASE.
int32 scrollpos_x
Currently shown x coordinate (virtual screen coordinate of topleft corner of the viewport).
int32 xmin
minimal world X coordinate of bounding box
HighLightStyle drawstyle
Lower bits 0-3 are reserved for detailed highlight information.
uint16 width_normal
The width when not zoomed out (normal font)
void SetViewportCatchmentStation(const Station *st, bool sel)
Select or deselect station for coverage area highlight.
static void DrawTileSelectionRect(const TileInfo *ti, PaletteID pal)
Draws a selection rectangle on a tile.
Map accessor functions for bridges.
bool IsInsideRotatedRectangle(int x, int y)
Checks whether a point is inside the selected a diagonal rectangle given by _thd.size and _thd...
static Slope SlopeWithThreeCornersRaised(Corner corner)
Returns the slope with all except one corner raised.
ZoomLevel zoom_max
maximum zoom out level
int virtual_width
width << zoom
void MarkTileDirtyByTile(TileIndex tile, int bridge_level_offset, int tile_height_override)
Mark a tile given by its index dirty for repaint.
static const PaletteID PALETTE_SEL_TILE_BLUE
This draws a blueish square (catchment areas for example)
Station view; Window numbers:
int DrawString(int left, int right, int top, const char *str, TextColour colour, StringAlignment align, bool underline, FontSize fontsize)
Draw string, possibly truncated to make it fit in its allocated space.
void ShowVehicleViewWindow(const Vehicle *v)
Shows the vehicle view window of the given vehicle.
static int CalcHeightdiff(HighLightStyle style, uint distance, TileIndex start_tile, TileIndex end_tile)
Calculates height difference between one tile and another.
Owner owner
Which company owns the vehicle?
void SetDirtyBlocks(int left, int top, int right, int bottom)
This function extends the internal _invalid_rect rectangle as it now contains the rectangle defined b...
bool smooth_scroll
smooth scroll viewports
autorail (one piece), lower bits: direction
static int GetViewportY(Point tile)
Returns the y coordinate in the viewport coordinate system where the given tile is painted...
#define lengthof(x)
Return the length of an fixed size array.
static Blitter * GetCurrentBlitter()
Get the current active blitter (always set by calling SelectBlitter).
VehicleID follow_vehicle
VehicleID to follow if following a vehicle, INVALID_VEHICLE otherwise.
static T min(const T a, const T b)
Returns the minimum of two values.
static void ClampViewportToMap(const ViewPort *vp, int *scroll_x, int *scroll_y)
Ensure that a given viewport has a valid scroll position.
static void AddCombinedSprite(SpriteID image, PaletteID pal, int x, int y, int z, const SubSprite *sub)
Adds a child sprite to a parent sprite.
bool ScrollWindowToTile(TileIndex tile, Window *w, bool instant)
Scrolls the viewport in a window to a given location.
Also allow 'diagonal rectangles'. Only usable in combination with HT_RECT or HT_POINT.
void SetObjectToPlaceWnd(CursorID icon, PaletteID pal, HighLightStyle mode, Window *w)
Change the cursor and mouse click/drag handling to a mode for performing special operations like tile...
uint32 StringID
Numeric value that represents a string, independent of the selected language.
Vehicle * First() const
Get the first vehicle of this vehicle chain.
Point new_outersize
New value for outersize; used to determine whether to redraw the selection.
drag only in horizontal direction
void DrawBox(int x, int y, int dx1, int dy1, int dx2, int dy2, int dx3, int dy3)
Draws the projection of a parallelepiped.
ViewPort * IsPtInWindowViewport(const Window *w, int x, int y)
Is a xy position inside the viewport of the window?
int32 dest_scrollpos_y
Current destination y coordinate to display (virtual screen coordinate of topleft corner of the viewp...
const SubSprite * sub
only draw a rectangular part of the sprite
void AddSortableSpriteToDraw(SpriteID image, PaletteID pal, int x, int y, int w, int h, int dz, int z, bool transparent, int bb_offset_x, int bb_offset_y, int bb_offset_z, const SubSprite *sub)
Draw a (transparent) sprite at given coordinates with a given bounding box.
static Slope RemoveHalftileSlope(Slope s)
Removes a halftile slope from a slope.
void ShowStationViewWindow(StationID station)
Opens StationViewWindow for given station.
bool make_square_red
Whether to give a tile a red selection.
uint16 height
Height of the sprite.
static T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
static const int MAX_TILE_EXTENT_TOP
Maximum top extent of tile relative to north corner (not considering bridges).
The most basic (normal) sprite.
void SetDirty() const
Mark entire window as dirty (in need of re-paint)
#define DEBUG(name, level,...)
Output a line of debugging information.
point (lower land, raise land, level land, ...)
Dimension GetStringBoundingBox(const char *str, FontSize start_fontsize)
Return the string dimension in pixels.
static HighLightStyle Check2x1AutoRail(int mode)
returns information about the 2x1 piece to be build.
int32 center
The center position of the sign.
static void MarkViewportDirty(const ViewPort *vp, int left, int top, int right, int bottom)
Marks a viewport as dirty for repaint if it displays (a part of) the area the needs to be repainted...
TileIndex tile
The base tile of the area.
const SubSprite * sub
only draw a rectangular part of the sprite
ViewportDragDropSelectionProcess select_proc
The procedure that has to be called when the selection is done.
void SetMouseCursor(CursorID sprite, PaletteID pal)
Assign a single non-animated sprite to the cursor.
Mask for the tile drag-type modes.
void UpdateTileSelection()
Updates tile highlighting for all cases.
static uint ScaleByMapSize1D(uint n)
Scales the given value by the maps circumference, where the given value is for a 256 by 256 map...
A pair-construct of a TileIndexDiff.
int * last_foundation_child[FOUNDATION_PART_END]
Tail of ChildSprite list of the foundations. (index into child_screen_sprites_to_draw) ...
int left
Screen coordinate left edge of the viewport.
static const int TILE_HEIGHT_STEP
One Z unit tile height difference is displayed as 50m.
void DrawViewport() const
Draw the viewport of this window.
void DeleteWindowById(WindowClass cls, WindowNumber number, bool force)
Delete a window by its class and window number (if it is open).
static TileIndexDiff ToTileIndexDiff(TileIndexDiffC tidc)
Return the offset between to tiles from a TileIndexDiffC struct.
execute the given command
static bool IsInRangeInclusive(int begin, int end, int check)
Check if the parameter "check" is inside the interval between begin and end, including both begin and...
void SetAnimatedMouseCursor(const AnimCursor *table)
Assign an animation to the cursor.
uint16 width
Width of the sprite.
Functions related to companies.
static StationID GetStationIndex(TileIndex t)
Get StationID from a tile.
static TileIndex TileVirtXY(uint x, uint y)
Get a tile from the virtual XY-coordinate.
bool ScrollMainWindowTo(int x, int y, int z, bool instant)
Scrolls the main window to given coordinates.
int32 dest_scrollpos_x
Current destination x coordinate to display (virtual screen coordinate of topleft corner of the viewp...
area of land in X and Y directions
static bool ViewportSortParentSpritesChecker()
This fallback sprite checker always exists.
static void AddChildSpriteToFoundation(SpriteID image, PaletteID pal, const SubSprite *sub, FoundationPart foundation_part, int extra_offs_x, int extra_offs_y)
Adds a child sprite to the active foundation.
Parent sprite that should be drawn.
static uint TilePixelHeightOutsideMap(int x, int y)
Returns the height of a tile in pixels, also for tiles outside the map (virtual "black" tiles)...
GUISettings gui
settings related to the GUI
SpriteID image
sprite to draw
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
Invisible tiles at the SW and SE border.
Base class for all vehicles.
void Build(It begin, It end)
Clear and rebuild the tree from a new sequence of elements,.
Data structure for viewport, display of a part of the world.
static void DrawTileSelection(const TileInfo *ti)
Checks if the specified tile is selected and if so draws selection using correct selectionstyle.
static void ViewportAddLandscape()
Add the landscape to the viewport, i.e.
Point InverseRemapCoords2(int x, int y, bool clamp_to_map, bool *clamped)
Map 2D viewport or smallmap coordinate to 3D world or tile coordinate.
uint32 SpriteID
The number of a sprite, without mapping bits and colourtables.
Time spent drawing world viewports in GUI.
uint32 TileIndex
The index/ID of a Tile.
static const PaletteID PALETTE_CRASH
Recolour sprite greying of crashed vehicles.
Window * z_front
The window in front of us in z-order.
static const byte _string_colourmap[17]
Colour mapping for TextColour.
uint DistanceManhattan(TileIndex t0, TileIndex t1)
Gets the Manhattan distance between the two given tiles.
bool diagonal
Whether the dragged area is a 45 degrees rotated rectangle.
static size_t GetNumItems()
Returns number of valid items in the pool.
All players in specific company.
void HandleClickOnSign(const Sign *si)
Handle clicking on a sign.
Helper class for getting the best sprite sorter.
static int GetBridgePixelHeight(TileIndex tile)
Get the height ('z') of a bridge in pixels.
bool(* VpSorterChecker)()
Type for method for checking whether a viewport sprite sorter exists.
TileIndex redsq
The tile that has to get a red selection.
static const int MAX_TILE_EXTENT_BOTTOM
Maximum bottom extent of tile relative to north corner (worst case: SLOPE_STEEP_N).
int32 ymax
maximal world Y coordinate of bounding box
static uint TileY(TileIndex tile)
Get the Y component of a tile.
int32 xmax
maximal world X coordinate of bounding box
when a sprite is to be displayed transparently, this bit needs to be set.
static T abs(const T a)
Returns the absolute value of (scalar) variable.
const Station * _viewport_highlight_station
Currently selected station for coverage area highlight.
void VpSelectTilesWithMethod(int x, int y, ViewportPlaceMethod method)
Selects tiles while dragging.
TileIndex xy
Base tile of the station.
void Reset()
Reset tile highlighting.
static void DrawSelectionSprite(SpriteID image, PaletteID pal, const TileInfo *ti, int z_offset, FoundationPart foundation_part)
Draws sprites between ground sprite and everything above.
static uint GB(const T x, const uint8 s, const uint8 n)
Fetch n bits from x, started at bit s.
Functions related to zooming.
static Point InverseRemapCoords(int x, int y)
Map 2D viewport or smallmap coordinate to 3D world or tile coordinate.
Slope
Enumeration for the slope-type.
Town view; Window numbers:
Neither foundation nor groundsprite drawn yet.
const TileTypeProcs *const _tile_type_procs[16]
Tile callback functions for each type of tile.
BitmapTileArea catchment_tiles
NOSAVE: Set of individual tiles covered by catchment area.
TownCache cache
Container for all cacheable data.
static uint MapMaxY()
Gets the maximum Y coordinate within the map, including MP_VOID.
void VpSetPresizeRange(TileIndex from, TileIndex to)
Highlights all tiles between a set of two tiles.
int16 x_offs
Number of pixels to shift the sprite to the right.
Used to only draw a part of the sprite.
Vehicle * CheckClickOnVehicle(const ViewPort *vp, int x, int y)
Find the vehicle close to the clicked coordinates.
byte max_bridge_height
maximum height of bridges
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...
static const uint TILE_UNIT_MASK
For masking in/out the inner-tile world coordinate units.
static const uint MAX_BUILDING_PIXELS
Maximum height of a building in pixels in #ZOOM_LVL_BASE. (Also applies to "bridge buildings" on the ...
Functions related to OTTD's landscape.
bool ScrollMainWindowToTile(TileIndex tile, bool instant)
Scrolls the viewport of the main window to a given location.
void OffsetGroundSprite(int x, int y)
Called when a foundation has been drawn for the current tile.
Functions related to commands.
Network functions used by other parts of OpenTTD.
VpSpriteSorter fct_sorter
The sorting function.
uint32 CursorID
The number of the cursor (sprite)
Coordinates of a point in 2D.
used for autorail highlighting (longer stretches), lower bits: direction
a steep slope falling to south (from north)
CompanyID _current_company
Company currently doing an action.
void DrawGroundSprite(SpriteID image, PaletteID pal, const SubSprite *sub, int extra_offs_x, int extra_offs_y)
Draws a ground sprite for the current tile.
TrackedViewportSign sign
Location of name sign, UpdateVirtCoord updates this.
Owner owner
The owner of this station.
Colours _company_colours[MAX_COMPANIES]
NOSAVE: can be determined from company structs.
static uint TileHeight(TileIndex tile)
Returns the height of a tile.
The colour translation of GRF's strings.
special mode used for highlighting while dragging (and for tunnels/docks)
static bool CheckClickOnViewportSign(const ViewPort *vp, int x, int y, const ViewportSign *sign)
Test whether a sign is below the mouse.
uint16 SignID
The type of the IDs of signs.
bool freeze
Freeze highlight in place.
EventState VpHandlePlaceSizingDrag()
Handle the mouse while dragging for placement/resizing.
Index of the small font in the font tables.
static uint SlopeToSpriteOffset(Slope s)
Returns the Sprite offset for a given Slope.
ConstructionSettings construction
construction of things in-game
Colour value is already a real palette colour index, not an index of a StringColour.
HighLightStyle
Highlighting draw styles.
Functions related to waypoints.
K-dimensional tree, specialised for 2-dimensional space.
DrawTileProc * draw_tile_proc
Called to render the tile and its contents to the screen.
void AddChildSpriteScreen(SpriteID image, PaletteID pal, int x, int y, bool transparent, const SubSprite *sub, bool scale)
Add a child sprite to a parent sprite.
static void free(const void *ptr)
Version of the standard free that accepts const pointers.
drag only in vertical direction
vehicle is accepted as target as well (bitmask)
ZoomLevel zoom
The zoom level of the viewport.
int width
width of the window (number of pixels to the right in x direction)
Metadata about the current highlighting.
static bool HasBit(const T x, const uint8 y)
Checks if a bit in a value is set.
void InitializeSpriteSorter()
Choose the "best" sprite sorter and set _vp_sprite_sorter.
Types related to sprite sorting.
PaletteID pal
palette to use
static const TileIndex INVALID_TILE
The very nice invalid tile marker.
ZoomLevel
All zoom levels we know.
static uint TileHeightOutsideMap(int x, int y)
Returns the height of a tile, also for tiles outside the map (virtual "black" tiles).
int virtual_top
Virtual top coordinate.
void ViewportAddString(const DrawPixelInfo *dpi, ZoomLevel small_from, const ViewportSign *sign, StringID string_normal, StringID string_small, StringID string_small_shadow, uint64 params_1, uint64 params_2, Colours colour)
Add a string to draw in the viewport.
int32 left
minimal screen X coordinate of sprite (= x + sprite->x_offs), reference point for child sprites ...
int32 WindowNumber
Number to differentiate different windows of the same class.
WindowClass window_class
Window class.
Specification of a rectangle with absolute coordinates of all edges.
WindowClass window_class
The WindowClass of the window that is responsible for the selection mode.
virtual void OnPlaceObject(Point pt, TileIndex tile)
The user clicked some place on the map when a tile highlight mode has been set.
The passed event is handled.
uint16 width_small
The width when zoomed out (small font)
TrackedViewportSign sign
NOSAVE: Dimensions of sign.
static uint MapMaxX()
Gets the maximum X coordinate within the map, including MP_VOID.
WindowNumber window_number
Window number within the window class.
void DrawGroundSpriteAt(SpriteID image, PaletteID pal, int32 x, int32 y, int z, const SubSprite *sub, int extra_offs_x, int extra_offs_y)
Draws a ground sprite at a specific world-coordinate relative to the current tile.
static bool IsInvisibilitySet(TransparencyOption to)
Check if the invisibility option bit is set and if we aren't in the game menu (there's never transpar...
FoundationPart
Enumeration of multi-part foundations.
static TileHighlightType GetTileHighlightType(TileIndex t)
Get tile highlight type of coverage area for a given tile.
Functions related to tile highlights.
HighLightStyle next_drawstyle
Queued, but not yet drawn style.
Window functions not directly related to making/drawing windows.
int top
Screen coordinate top edge of the viewport.
void SetDirty()
Mark the linkgraph dirty to be rebuilt next time Draw() is called.
static void ViewportDrawDirtyBlocks()
Draw/colour the blocks that have been redrawn.
Point outersize
Size, in tile "units", of the blue coverage area excluding the side of the selected area...
Makes the background transparent if set.
#define TILE_ADD(x, y)
Adds to tiles together.
ZoomLevel zoom_min
minimum zoom out level
ViewportData * viewport
Pointer to viewport data, if present.
static const CursorID SPR_CURSOR_MOUSE
Cursor sprite numbers.
Base classes/functions for stations.
bool kdtree_valid
Are the sign data valid for use with the _viewport_sign_kdtree?
static Station * Get(size_t index)
Gets station with given index.
static T Delta(const T a, const T b)
Returns the (absolute) difference between two (scalar) variables.
bool comparison_done
Used during sprite sorting: true if sprite has been compared with all other sprites.
CargoTypes GetCargoMask()
Get a bitmask of the currently shown cargoes.
static Point RemapCoords2(int x, int y)
Map 3D world or tile coordinate to equivalent 2D coordinate as used in the viewports and smallmap...
int32 scrollpos_y
Currently shown y coordinate (virtual screen coordinate of topleft corner of the viewport).
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
The object is owned by a superuser / goal script.
static bool IsCompanyBuildableVehicleType(VehicleType type)
Is the given vehicle type buildable by a company?
const SubSprite * sub
only draw a rectangular part of the sprite
bool ScrollWindowTo(int x, int y, int z, Window *w, bool instant)
Scrolls the viewport in a window to a given location.
Base class for all station-ish types.
static bool IsTransparencySet(TransparencyOption to)
Check if the transparency option bit is set and if we aren't in the game menu (there's never transpar...
Factory to 'query' all available blitters.
byte dirty
Whether the build station window needs to redraw due to the changed selection.
static uint TilePixelHeight(TileIndex tile)
Returns the height of a tile in pixels.
static TileIndex TileXY(uint x, uint y)
Returns the TileIndex of a coordinate.
static Corner OppositeCorner(Corner corner)
Returns the opposite corner.
static void DrawTileHighlightType(const TileInfo *ti, TileHighlightType tht)
Draw tile highlight for coverage area highlight.
This file defines all the the animated cursors.
virtual void OnPlaceMouseUp(ViewportPlaceMethod select_method, ViewportDragDropSelectionProcess select_proc, Point pt, TileIndex start_tile, TileIndex end_tile)
The user has dragged over the map when the tile highlight mode has been set.
int height
Height of the window (number of pixels down in y direction)
void MarkWholeScreenDirty()
This function mark the whole screen as dirty.
void UpdateViewportPosition(Window *w)
Update the viewport position being displayed.
#define FOR_ALL_WINDOWS_FROM_BACK_FROM(w, start)
Iterate over all windows.
static int GetTileMaxPixelZ(TileIndex tile)
Get top height of the tile.
static void CalcRaildirsDrawstyle(int x, int y, int method)
while dragging
static void SetDParam(uint n, uint64 v)
Set a string parameter v at index n in the global string parameter array.
int width
Screen width of the viewport.