85 #include "viewport_kdtree.h" 96 #include "table/strings.h" 101 Point _tile_fract_coords;
105 static int _viewport_sign_maxwidth = 0;
157 typedef std::vector<TileSpriteToDraw> TileSpriteToDrawVector;
158 typedef std::vector<StringSpriteToDraw> StringSpriteToDrawVector;
159 typedef std::vector<ParentSpriteToDraw> ParentSpriteToDrawVector;
160 typedef std::vector<ChildScreenSpriteToDraw> ChildScreenSpriteToDrawVector;
166 StringSpriteToDrawVector string_sprites_to_draw;
167 TileSpriteToDrawVector tile_sprites_to_draw;
168 ParentSpriteToDrawVector parent_sprites_to_draw;
170 ChildScreenSpriteToDrawVector child_screen_sprites_to_draw;
176 int foundation[FOUNDATION_PART_END];
178 int *last_foundation_child[FOUNDATION_PART_END];
179 Point foundation_offset[FOUNDATION_PART_END];
188 bool _draw_bounding_boxes =
false;
189 bool _draw_dirty_blocks =
false;
190 uint _dirty_block_colour = 0;
193 static Point MapXYZToViewport(
const ViewPort *vp,
int x,
int y,
int z)
201 void DeleteWindowViewport(
Window *w)
223 int width,
int height, uint32 follow_flags,
ZoomLevel zoom)
241 if (follow_flags & 0x80000000) {
252 pt = MapXYZToViewport(vp, x, y, GetSlopePixelZ(x, y));
260 vp->overlay =
nullptr;
267 static Point _vp_move_offs;
269 static void DoSetViewportPosition(
const Window *w,
int left,
int top,
int width,
int height)
272 if (left + width > w->
left &&
274 top + height > w->
top &&
277 if (left < w->left) {
278 DoSetViewportPosition(w, left, top, w->
left - left, height);
279 DoSetViewportPosition(w, left + (w->
left - left), top, width - (w->
left - left), height);
284 DoSetViewportPosition(w, left, top, (w->
left + w->
width - left), height);
285 DoSetViewportPosition(w, left + (w->
left + w->
width - left), top, width - (w->
left + w->
width - left), height);
290 DoSetViewportPosition(w, left, top, width, (w->
top - top));
291 DoSetViewportPosition(w, left, top + (w->
top - top), width, height - (w->
top - top));
296 DoSetViewportPosition(w, left, top, width, (w->
top + w->
height - top));
297 DoSetViewportPosition(w, left, top + (w->
top + w->
height - top), width, height - (w->
top + w->
height - top));
306 int xo = _vp_move_offs.x;
307 int yo = _vp_move_offs.y;
309 if (
abs(xo) >= width ||
abs(yo) >= height) {
311 RedrawScreenRect(left, top, left + width, top + height);
315 GfxScroll(left, top, width, height, xo, yo);
318 RedrawScreenRect(left, top, xo + left, top + height);
322 RedrawScreenRect(left + width + xo, top, left + width, top + height);
327 RedrawScreenRect(left, top, width + left, top + yo);
329 RedrawScreenRect(left, top + height + yo, width + left, top + height);
334 static void SetViewportPosition(
Window *w,
int x,
int y)
340 int left, top, width, height;
356 if (old_top == 0 && old_left == 0)
return;
358 _vp_move_offs.x = old_left;
359 _vp_move_offs.y = old_top;
371 i = left + width - _screen.width;
372 if (i >= 0) width -= i;
380 i = top + height - _screen.height;
381 if (i >= 0) height -= i;
383 if (height > 0) DoSetViewportPosition(w->
z_front, left, top, width, height);
422 Point pt = { -1, -1 };
434 static Point GetTileFromScreenXY(
int x,
int y,
int zoom_x,
int zoom_y)
448 Point GetTileBelowCursor()
450 return GetTileFromScreenXY(_cursor.
pos.x, _cursor.
pos.y, _cursor.
pos.x, _cursor.
pos.y);
460 x = ((_cursor.
pos.x - vp->
left) >> 1) + (vp->
width >> 2);
461 y = ((_cursor.
pos.y - vp->
top) >> 1) + (vp->
height >> 2);
467 return GetTileFromScreenXY(_cursor.
pos.x, _cursor.
pos.y, x + vp->
left, y + vp->
top);
503 _vd.tile_sprites_to_draw.emplace_back();
509 ts.
x = pt.x + extra_offs_x;
510 ts.
y = pt.y + extra_offs_y;
527 assert(
IsInsideMM(foundation_part, 0, FOUNDATION_PART_END));
528 assert(_vd.
foundation[foundation_part] != -1);
532 int *old_child = _vd.last_child;
535 AddChildSpriteScreen(image, pal, offs.x + extra_offs_x, offs.y + extra_offs_y,
false, sub,
false);
538 _vd.last_child = old_child;
563 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);
599 default: NOT_REACHED();
626 if (pt.x + spr->
x_offs >= _vd.dpi.left + _vd.dpi.width ||
628 pt.y + spr->
y_offs >= _vd.dpi.top + _vd.dpi.height ||
661 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)
663 int32 left, right, top, bottom;
678 _vd.last_child =
nullptr;
681 int tmp_left, tmp_top, tmp_x = pt.x, tmp_y = pt.y;
684 if (image == SPR_EMPTY_BOUNDING_BOX) {
685 left = tmp_left =
RemapCoords(x + w , y + bb_offset_y, z + bb_offset_z).x;
686 right =
RemapCoords(x + bb_offset_x, y + h , z + bb_offset_z).x + 1;
687 top = tmp_top =
RemapCoords(x + bb_offset_x, y + bb_offset_y, z + dz ).y;
688 bottom =
RemapCoords(x + w , y + h , z + bb_offset_z).y + 1;
691 left = tmp_left = (pt.x += spr->
x_offs);
692 right = (pt.x + spr->
width );
693 top = tmp_top = (pt.y += spr->
y_offs);
694 bottom = (pt.y + spr->
height);
697 if (_draw_bounding_boxes && (image != SPR_EMPTY_BOUNDING_BOX)) {
699 left =
min(left ,
RemapCoords(x + w , y + bb_offset_y, z + bb_offset_z).x);
700 right =
max(right ,
RemapCoords(x + bb_offset_x, y + h , z + bb_offset_z).x + 1);
701 top =
min(top ,
RemapCoords(x + bb_offset_x, y + bb_offset_y, z + dz ).y);
702 bottom =
max(bottom,
RemapCoords(x + w , y + h , z + bb_offset_z).y + 1);
706 if (left >= _vd.dpi.left + _vd.dpi.width ||
707 right <= _vd.dpi.left ||
708 top >= _vd.dpi.top + _vd.dpi.height ||
709 bottom <= _vd.dpi.top) {
713 _vd.parent_sprites_to_draw.emplace_back();
724 ps.
xmin = x + bb_offset_x;
725 ps.
xmax = x +
max(bb_offset_x, w) - 1;
727 ps.
ymin = y + bb_offset_y;
728 ps.
ymax = y +
max(bb_offset_y, h) - 1;
730 ps.
zmin = z + bb_offset_z;
731 ps.
zmax = z +
max(bb_offset_z, dz) - 1;
786 if (begin > end)
Swap(begin, end);
787 return begin <= check && check <= end;
798 int dist_a = (_thd.
size.x + _thd.
size.y);
799 int dist_b = (_thd.
size.x - _thd.
size.y);
800 int a = ((x - _thd.
pos.x) + (y - _thd.
pos.y));
801 int b = ((x - _thd.
pos.x) - (y - _thd.
pos.y));
822 if (_vd.last_child ==
nullptr)
return;
830 *_vd.last_child = (uint)_vd.child_screen_sprites_to_draw.size();
832 _vd.child_screen_sprites_to_draw.emplace_back();
837 cs.x = scale ? x * ZOOM_LVL_BASE : x;
838 cs.y = scale ? y * ZOOM_LVL_BASE : y;
846 _vd.last_child = &cs.
next;
849 static void AddStringToDraw(
int x,
int y,
StringID string, uint64 params_1, uint64 params_2, Colours colour, uint16 width)
852 _vd.string_sprites_to_draw.emplace_back();
857 ss.params[0] = params_1;
858 ss.params[1] = params_2;
900 SpriteID sel2 = SPR_HALFTILE_SELECTION_FLAT + halftile_corner;
905 sel = SPR_HALFTILE_SELECTION_DOWN;
909 sel += opposite_corner;
916 static bool IsPartOfAutoLine(
int px,
int py)
926 case HT_DIR_HU:
return px == -py || px == -py - 16;
927 case HT_DIR_HL:
return px == -py || px == -py + 16;
928 case HT_DIR_VL:
return px == py || px == py + 16;
929 case HT_DIR_VR:
return px == py || px == py - 16;
962 static const uint _lower_rail[4] = { 5U, 2U, 4U, 3U };
964 if (autorail_type != _lower_rail[halftile_corner]) {
971 offset = _AutorailTilehSprite[autorail_tileh][autorail_type];
973 image = SPR_AUTORAIL_BASE + offset;
976 image = SPR_AUTORAIL_BASE - offset;
983 enum TileHighlightType {
1000 if (_viewport_highlight_station !=
nullptr) {
1002 if (_viewport_highlight_station->TileIsInCatchment(t))
return THT_BLUE;
1005 if (_viewport_highlight_town !=
nullptr) {
1008 TileHighlightType type = THT_RED;
1011 if (st->TileIsInCatchment(t))
return THT_BLUE;
1035 case THT_NONE:
break;
1050 if (_town_local_authority_kdtree.
Count() == 0)
return;
1116 if ((halftile_corner == CORNER_W) || (halftile_corner == CORNER_E)) z +=
TILE_HEIGHT;
1117 if (halftile_corner != CORNER_S) {
1128 }
else if (IsPartOfAutoLine(ti->
x, ti->
y)) {
1146 if (!is_redsq && (tht == THT_NONE || tht == THT_RED) && _thd.
outersize.x > 0 &&
1172 assert(_vd.dpi.top <= _vd.dpi.top + _vd.dpi.height);
1173 assert(_vd.dpi.left <= _vd.dpi.left + _vd.dpi.width);
1191 int left_column = (upper_left.y - upper_left.x) / (
int)
TILE_SIZE - 2;
1192 int right_column = (upper_right.y - upper_right.x) / (
int)
TILE_SIZE + 2;
1200 int row = (upper_left.x + upper_left.y) / (
int)
TILE_SIZE - 2;
1201 bool last_row =
false;
1202 for (; !last_row; row++) {
1204 for (
int column = left_column; column <= right_column; column++) {
1206 if ((row + column) % 2 != 0)
continue;
1209 tilecoord.x = (row - column) / 2;
1210 tilecoord.y = (row + column) / 2;
1211 assert(column == tilecoord.y - tilecoord.x);
1212 assert(row == tilecoord.y + tilecoord.x);
1216 _cur_ti = &tile_info;
1222 tile_info.
tile =
TileXY(tilecoord.x, tilecoord.y);
1246 int min_visible_height = viewport_y - (_vd.dpi.top + _vd.dpi.height);
1247 bool tile_visible = min_visible_height <= 0;
1266 if ((tilecoord.x <= 0 || tilecoord.y <= 0) && min_visible_height < potential_bridge_height +
MAX_TILE_EXTENT_TOP) last_row =
false;
1296 bool small = dpi->zoom >= small_from;
1298 int left = dpi->left;
1300 int right = left + dpi->width;
1301 int bottom = top + dpi->height;
1306 if (bottom < sign->top ||
1307 top > sign->
top + sign_height ||
1308 right < sign->center - sign_half_width ||
1309 left > sign->
center + sign_half_width) {
1314 AddStringToDraw(sign->
center - sign_half_width, sign->
top, string_normal, params_1, params_2, colour, sign->
width_normal);
1316 int shadow_offset = 0;
1317 if (string_small_shadow != STR_NULL) {
1319 AddStringToDraw(sign->
center - sign_half_width + shadow_offset, sign->
top, string_small_shadow, params_1, params_2, INVALID_COLOUR, sign->
width_small);
1321 AddStringToDraw(sign->
center - sign_half_width, sign->
top - shadow_offset, string_small, params_1, params_2,
1330 const int max_tw = _viewport_sign_maxwidth / 2 + 1;
1335 r.right += expand_x;
1337 r.bottom += expand_y;
1344 Rect search_rect{ dpi->left, dpi->top, dpi->left + dpi->width, dpi->top + dpi->height };
1345 search_rect = ExpandRectWithViewportSignMargins(search_rect, dpi->zoom);
1357 std::vector<const BaseStation *> stations;
1358 std::vector<const Town *> towns;
1359 std::vector<const Sign *> signs;
1362 switch (item.type) {
1363 case ViewportSignKdtreeItem::VKI_STATION:
1364 if (!show_stations) break;
1365 st = BaseStation::Get(item.id.station);
1368 if (!show_competitors && _local_company != st->owner && st->owner != OWNER_NONE) break;
1370 stations.push_back(st);
1373 case ViewportSignKdtreeItem::VKI_WAYPOINT:
1374 if (!show_waypoints) break;
1375 st = BaseStation::Get(item.id.station);
1378 if (!show_competitors && _local_company != st->owner && st->owner != OWNER_NONE) break;
1380 stations.push_back(st);
1383 case ViewportSignKdtreeItem::VKI_TOWN:
1384 if (!show_towns) break;
1385 towns.push_back(Town::Get(item.id.town));
1388 case ViewportSignKdtreeItem::VKI_SIGN:
1389 if (!show_signs) break;
1390 si = Sign::Get(item.id.sign);
1395 if (!show_competitors && _local_company != si->owner && si->owner != OWNER_DEITY) break;
1397 signs.push_back(si);
1407 for (
const auto *t : towns) {
1410 STR_VIEWPORT_TOWN_TINY_WHITE, STR_VIEWPORT_TOWN_TINY_BLACK,
1411 t->index, t->cache.population);
1414 for (
const auto *si : signs) {
1421 for (
const auto *st : stations) {
1425 STR_VIEWPORT_STATION, STR_VIEWPORT_STATION + 1, STR_NULL,
1430 STR_VIEWPORT_WAYPOINT, STR_VIEWPORT_WAYPOINT + 1, STR_NULL,
1446 if (this->width_normal != 0) this->MarkDirty();
1452 GetString(buffer, str,
lastof(buffer));
1454 this->center = center;
1457 if (str_small != STR_NULL) {
1458 GetString(buffer, str_small,
lastof(buffer));
1477 zoomlevels[zoom].left = this->center -
ScaleByZoom(this->width_normal / 2 + 1, zoom);
1478 zoomlevels[zoom].top = this->top -
ScaleByZoom(1, zoom);
1479 zoomlevels[zoom].right = this->center +
ScaleByZoom(this->width_normal / 2 + 1, zoom);
1484 FOR_ALL_WINDOWS_FROM_BACK(w) {
1486 if (vp !=
nullptr && vp->
zoom <= maxzoom) {
1487 assert(vp->
width != 0);
1494 static void ViewportDrawTileSprites(
const TileSpriteToDrawVector *tstdv)
1510 auto psdvend = psdv->end();
1511 auto psd = psdv->begin();
1512 while (psd != psdvend) {
1522 for (
auto psd2 = psd + 1; psd2 != psdvend; psd2++) {
1557 for (
auto psd3 = psd2; psd3 > psd; psd3--) {
1558 *psd3 = *(psd3 - 1);
1565 static void ViewportDrawParentSprites(
const ParentSpriteToSortVector *psd,
const ChildScreenSpriteToDrawVector *csstdv)
1568 if (ps->image != SPR_EMPTY_BOUNDING_BOX)
DrawSpriteViewport(ps->image, ps->pal, ps->x, ps->y, ps->sub);
1570 int child_idx = ps->first_child;
1571 while (child_idx >= 0) {
1573 child_idx = cs->
next;
1592 pt2.x - pt1.x, pt2.y - pt1.y,
1593 pt3.x - pt1.x, pt3.y - pt1.y,
1594 pt4.x - pt1.x, pt4.y - pt1.y);
1613 byte bo =
UnScaleByZoom(dpi->left + dpi->top, dpi->zoom) & 1;
1615 for (
int i = (bo ^= 1); i < right; i += 2) blitter->
SetPixel(dst, i, 0, (uint8)colour);
1616 dst = blitter->
MoveTo(dst, 0, 1);
1617 }
while (--bottom > 0);
1620 static void ViewportDrawStrings(
ZoomLevel zoom,
const StringSpriteToDrawVector *sstdv)
1624 bool small =
HasBit(ss.width, 15);
1625 int w =
GB(ss.width, 0, 15);
1633 if (ss.colour != INVALID_COLOUR) {
1646 x, y, x + w, y + h, ss.colour,
1656 void ViewportDoDraw(
const ViewPort *vp,
int left,
int top,
int right,
int bottom)
1659 _cur_dpi = &_vd.dpi;
1661 _vd.dpi.zoom = vp->
zoom;
1666 _vd.dpi.width = (right - left) & mask;
1667 _vd.dpi.height = (bottom - top) & mask;
1668 _vd.dpi.left = left & mask;
1669 _vd.dpi.top = top & mask;
1670 _vd.dpi.pitch = old_dpi->pitch;
1671 _vd.last_child =
nullptr;
1681 ViewportAddKdtreeSigns(&_vd.dpi);
1683 DrawTextEffects(&_vd.dpi);
1685 if (_vd.tile_sprites_to_draw.size() != 0) ViewportDrawTileSprites(&_vd.tile_sprites_to_draw);
1687 for (
auto &psd : _vd.parent_sprites_to_draw) {
1708 vp->overlay->
Draw(&dp);
1711 if (_vd.string_sprites_to_draw.size() != 0) {
1715 ViewportDrawStrings(zoom, &_vd.string_sprites_to_draw);
1720 _vd.string_sprites_to_draw.clear();
1721 _vd.tile_sprites_to_draw.clear();
1722 _vd.parent_sprites_to_draw.clear();
1724 _vd.child_screen_sprites_to_draw.clear();
1734 if ((bottom - top) > (right - left)) {
1735 int t = (top + bottom) >> 1;
1739 int t = (left + right) >> 1;
1753 static inline void ViewportDraw(
const ViewPort *vp,
int left,
int top,
int right,
int bottom)
1755 if (right <= vp->left || bottom <= vp->top)
return;
1757 if (left >= vp->
left + vp->
width)
return;
1759 if (left < vp->left) left = vp->
left;
1762 if (top >= vp->
top + vp->
height)
return;
1764 if (top < vp->top) top = vp->
top;
1779 dpi->left += this->left;
1780 dpi->top += this->top;
1782 ViewportDraw(this->viewport, dpi->left, dpi->top, dpi->left + dpi->width, dpi->top + dpi->height);
1784 dpi->left -= this->left;
1785 dpi->top -= this->top;
1832 SetViewportPosition(w, pt.x, pt.y);
1840 bool update_overlay =
false;
1841 if (delta_x != 0 || delta_y != 0) {
1858 if (update_overlay) RebuildViewportOverlay(w);
1874 right += (1 << vp->
zoom) - 1;
1875 bottom += (1 << vp->
zoom) - 1;
1878 if (right <= 0)
return;
1881 if (bottom <= 0)
return;
1910 FOR_ALL_WINDOWS_FROM_BACK(w) {
1912 if (vp !=
nullptr) {
1913 assert(vp->
width != 0);
1919 void ConstrainAllViewportsZoom()
1922 FOR_ALL_WINDOWS_FROM_FRONT(w) {
1923 if (w->
viewport ==
nullptr)
continue;
1959 int x_size = _thd.
size.x;
1960 int y_size = _thd.
size.y;
1963 int x_start = _thd.
pos.x;
1964 int y_start = _thd.
pos.y;
1968 x_start += _thd.
offs.x;
1970 y_start += _thd.
offs.y;
1976 assert(x_size >= 0);
1977 assert(y_size >= 0);
1986 assert((x_end | y_end | x_start | y_start) %
TILE_SIZE == 0);
2007 int top_y = y_start;
2028 static const int OVERLAY_WIDTH = 4 * ZOOM_LVL_BASE;
2034 if (top_x != x_start) {
2041 if (bot_y != y_end) {
2046 }
while (bot_x >= top_x);
2049 int a_size = x_size + y_size, b_size = x_size - y_size;
2054 for (
int a = -interval_a; a != a_size + interval_a; a += interval_a) {
2055 for (
int b = -interval_b; b != b_size + interval_b; b += interval_b) {
2068 void SetSelectionRed(
bool b)
2088 return y >= sign->
top && y < sign->
top + sign_height &&
2089 x >= sign->
center - sign_half_width && x < sign->
center + sign_half_width;
2102 if (_game_mode == GM_MENU)
return false;
2107 Rect search_rect{ x - 1, y - 1, x + 1, y + 1 };
2108 search_rect = ExpandRectWithViewportSignMargins(search_rect, vp->
zoom);
2118 Town *t =
nullptr, *last_t =
nullptr;
2119 Sign *si =
nullptr, *last_si =
nullptr;
2123 switch (item.type) {
2124 case ViewportSignKdtreeItem::VKI_STATION:
2125 if (!show_stations) break;
2126 st = BaseStation::Get(item.id.station);
2127 if (!show_competitors && _local_company != st->owner && st->owner != OWNER_NONE) break;
2128 if (CheckClickOnViewportSign(vp, x, y, &st->sign)) last_st = st;
2131 case ViewportSignKdtreeItem::VKI_WAYPOINT:
2132 if (!show_waypoints) break;
2133 st = BaseStation::Get(item.id.station);
2134 if (!show_competitors && _local_company != st->owner && st->owner != OWNER_NONE) break;
2135 if (CheckClickOnViewportSign(vp, x, y, &st->sign)) last_st = st;
2138 case ViewportSignKdtreeItem::VKI_TOWN:
2139 if (!show_towns) break;
2140 t = Town::Get(item.id.town);
2141 if (CheckClickOnViewportSign(vp, x, y, &t->cache.sign)) last_t = t;
2144 case ViewportSignKdtreeItem::VKI_SIGN:
2145 if (!show_signs) break;
2146 si = Sign::Get(item.id.sign);
2147 if (!show_competitors && _local_company != si->owner && si->owner != OWNER_DEITY) break;
2148 if (CheckClickOnViewportSign(vp, x, y, &si->sign)) last_si = si;
2157 if (last_st !=
nullptr) {
2164 }
else if (last_t !=
nullptr) {
2165 ShowTownViewWindow(last_t->index);
2167 }
else if (last_si !=
nullptr) {
2179 item.type = VKI_STATION;
2180 item.id.station = id;
2185 pt.y -= 32 * ZOOM_LVL_BASE;
2192 _viewport_sign_maxwidth = max<int>(_viewport_sign_maxwidth, st->
sign.
width_normal);
2200 item.type = VKI_WAYPOINT;
2201 item.id.station = id;
2206 pt.y -= 32 * ZOOM_LVL_BASE;
2212 _viewport_sign_maxwidth = max<int>(_viewport_sign_maxwidth, st->
sign.
width_normal);
2220 item.type = VKI_TOWN;
2228 pt.y -= 24 * ZOOM_LVL_BASE;
2242 item.type = VKI_SIGN;
2248 pt.y -= 6 * ZOOM_LVL_BASE;
2254 _viewport_sign_maxwidth = max<int>(_viewport_sign_maxwidth, sign->sign.
width_normal);
2259 void RebuildViewportKdtree()
2262 _viewport_sign_maxwidth = 0;
2264 std::vector<ViewportSignKdtreeItem> items;
2268 FOR_ALL_STATIONS(st) {
2269 items.push_back(ViewportSignKdtreeItem::MakeStation(st->
index));
2274 items.push_back(ViewportSignKdtreeItem::MakeWaypoint(wp->
index));
2278 FOR_ALL_TOWNS(town) {
2279 items.push_back(ViewportSignKdtreeItem::MakeTown(town->
index));
2283 FOR_ALL_SIGNS(sign) {
2284 items.push_back(ViewportSignKdtreeItem::MakeSign(sign->
index));
2287 _viewport_sign_kdtree.
Build(items.begin(), items.end());
2291 static bool CheckClickOnLandscape(
const ViewPort *vp,
int x,
int y)
2295 if (pt.x != -1)
return ClickTile(
TileVirtXY(pt.x, pt.y));
2299 static void PlaceObject()
2304 pt = GetTileBelowCursor();
2305 if (pt.x == -1)
return;
2320 bool HandleViewportClicked(
const ViewPort *vp,
int x,
int y)
2335 bool result = CheckClickOnLandscape(vp, x, y);
2352 void RebuildViewportOverlay(
Window *w)
2354 if (w->
viewport->overlay !=
nullptr &&
2377 z = GetSlopePixelZ(x, y);
2391 RebuildViewportOverlay(w);
2452 void SetTileSelectBigSize(
int ox,
int oy,
int sx,
int sy)
2473 this->new_pos.x = 0;
2474 this->new_pos.y = 0;
2512 bool new_diagonal =
false;
2524 new_diagonal =
true;
2526 if (x1 >= x2)
Swap(x1, x2);
2527 if (y1 >= y2)
Swap(y1, y2);
2533 if (!new_diagonal) {
2540 Point pt = GetTileBelowCursor();
2572 default: NOT_REACHED();
2620 static void HideMeasurementTooltips()
2659 void VpSetPlaceSizingLimit(
int limit)
2683 HideMeasurementTooltips();
2687 static void VpStartPreSizing()
2699 int fxpy = _tile_fract_coords.x + _tile_fract_coords.y;
2701 int fxmy = _tile_fract_coords.x - _tile_fract_coords.y;
2705 default: NOT_REACHED();
2707 if (fxpy >= 20 && sxpy <= 12)
return HT_DIR_HL;
2708 if (fxmy < -3 && sxmy > 3)
return HT_DIR_VR;
2712 if (fxmy > 3 && sxmy < -3)
return HT_DIR_VL;
2713 if (fxpy <= 12 && sxpy >= 20)
return HT_DIR_HU;
2717 if (fxmy > 3 && sxmy < -3)
return HT_DIR_VL;
2718 if (fxpy >= 20 && sxpy <= 12)
return HT_DIR_HL;
2722 if (fxmy < -3 && sxmy > 3)
return HT_DIR_VR;
2723 if (fxpy <= 12 && sxpy >= 20)
return HT_DIR_HU;
2743 uint start_x =
TileX(start_tile);
2744 uint start_y =
TileY(start_tile);
2745 uint end_x =
TileX(end_tile);
2746 uint end_y =
TileY(end_tile);
2750 case HT_LINE:
return (end_x > start_x || (end_x == start_x && end_y > start_y));
2753 case HT_POINT:
return (end_x != start_x && end_y < start_y);
2754 default: NOT_REACHED();
2780 if (start_tile == end_tile)
return 0;
2781 if (swap)
Swap(start_tile, end_tile);
2792 byte style_t = (byte)(
TileX(end_tile) >
TileX(start_tile));
2807 {1, 0}, {1, 1}, {0, 1}, {1, 1},
2808 {1, 0}, {0, 0}, {1, 0}, {1, 1},
2809 {1, 0}, {1, 1}, {0, 1}, {1, 1},
2811 {0, 1}, {0, 0}, {1, 0}, {0, 0},
2812 {0, 1}, {0, 0}, {1, 1}, {0, 1},
2813 {1, 0}, {0, 0}, {0, 0}, {0, 1},
2823 if (swap && distance == 0) style = flip_style_direction[style];
2826 byte style_t = style * 2;
2827 assert(style_t <
lengthof(heightdiff_line_by_dir) - 13);
2834 if (distance == 0) style_t = flip_style_direction[style] * 2;
2835 assert(style_t <
lengthof(heightdiff_line_by_dir) - 13);
2843 if (swap)
Swap(h0, h1);
2847 static const StringID measure_strings_length[] = {STR_NULL, STR_MEASURE_LENGTH, STR_MEASURE_LENGTH_HEIGHTDIFF};
2857 if (test >= 0)
return;
2859 other += mult * test;
2872 if (test <= max)
return;
2874 other += mult * (test -
max);
2917 int offset = (raw_dx - raw_dy) / 2;
2952 int offset = (raw_dx + raw_dy + (int)
TILE_SIZE) / 2;
3001 }
else if (w > h * 2) {
3004 }
else if (h > w * 2) {
3018 }
else if (d >= 0) {
3029 }
else if (d >= 0) {
3042 }
else if (d >= 0) {
3053 }
else if (d >= 0) {
3071 if (distance != 1) {
3077 distance =
CeilDiv(distance, 2);
3080 params[index++] = distance;
3081 if (heightdiff != 0) params[index++] = heightdiff;
3130 if (
abs(sy - y) <
abs(sx - x)) {
3137 goto calc_heightdiff_single_direction;
3146 goto calc_heightdiff_single_direction;
3156 calc_heightdiff_single_direction:;
3158 x = sx +
Clamp(x - sx, -limit, limit);
3159 y = sy +
Clamp(y - sy, -limit, limit);
3168 if (distance != 1) {
3176 params[index++] = distance;
3177 if (heightdiff != 0) params[index++] = heightdiff;
3186 x = sx +
Clamp(x - sx, -limit, limit);
3187 y = sy +
Clamp(y - sy, -limit, limit);
3192 static const StringID measure_strings_area[] = {
3193 STR_NULL, STR_NULL, STR_MEASURE_AREA, STR_MEASURE_AREA_HEIGHTDIFF
3219 int a_max = dist_x + dist_y;
3220 int b_max = dist_y - dist_x;
3224 a_max =
abs(a_max + (a_max > 0 ? 2 : -2)) / 2;
3225 b_max =
abs(b_max + (b_max > 0 ? 2 : -2)) / 2;
3231 if (a_max != 1 || b_max != 1) {
3238 }
else if (dy == 1) {
3243 if (dx != 1 || dy != 1) {
3246 params[index++] = dx - (style &
HT_POINT ? 1 : 0);
3247 params[index++] = dy - (style &
HT_POINT ? 1 : 0);
3248 if (heightdiff != 0) params[index++] = heightdiff;
3255 default: NOT_REACHED();
3298 HideMeasurementTooltips();
3339 HideMeasurementTooltips();
3400 { &ViewportSortParentSpritesSSE41Checker, &ViewportSortParentSpritesSSE41 },
3408 for (uint i = 0; i <
lengthof(_vp_sprite_sorters); i++) {
3409 if (_vp_sprite_sorters[i].fct_checker()) {
3410 _vp_sprite_sorter = _vp_sprite_sorters[i].
fct_sorter;
3414 assert(_vp_sprite_sorter !=
nullptr);
3450 static void MarkCatchmentTilesDirty()
3480 MarkCatchmentTilesDirty();
3483 MarkCatchmentTilesDirty();
3485 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.
byte type
Type of this airport,.
the north corner of the tile is raised
Corner
Enumeration of tile corners.
uint32 PaletteID
The number of the palette.
StationFacility facilities
The facilities that this station has.
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
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
ViewportSign sign
NOSAVE: Dimensions of sign.
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.
ViewportSign sign
Location of name sign, UpdateVirtCoord updates this.
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
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.
int GetTileMaxZ(TileIndex t)
Get top height of the tile inside the map.
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.
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.
Airport airport
Tile area the airport covers.
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)
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.
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.
#define FOR_ALL_WAYPOINTS(var)
Iterate over all waypoints.
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.