2 * This file is part of OpenTTD.
3 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
4 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
5 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
9 * @file viewport.cpp Handling of all viewports.
12 * The in-game coordinate system looks like this *
28 * @defgroup vp_column_row Rows and columns in the viewport
30 * Columns are vertical sections of the viewport that are half a tile wide.
31 * The origin, i.e. column 0, is through the northern and southern most tile.
32 * This means that the column of e.g. Tile(0, 0) and Tile(100, 100) are in
33 * column number 0. The negative columns are towards the left of the screen,
34 * or towards the west, whereas the positive ones are towards respectively
36 * With half a tile wide is meant that the next column of tiles directly west
37 * or east of the centre line are respectively column -1 and 1. Their tile
38 * centers are only half a tile from the center of their adjoining tile when
39 * looking only at the X-coordinate.
58 * Rows are horizontal sections of the viewport, also half a tile wide.
59 * This time the northern most tile on the map defines 0 and
60 * everything south of that has a positive number.
64 #include "core/backup_type.hpp"
65 #include "landscape.h"
66 #include "viewport_func.h"
67 #include "station_base.h"
68 #include "waypoint_base.h"
70 #include "signs_base.h"
71 #include "signs_func.h"
72 #include "vehicle_base.h"
73 #include "vehicle_gui.h"
74 #include "blitter/factory.hpp"
75 #include "strings_func.h"
76 #include "zoom_func.h"
77 #include "vehicle_func.h"
78 #include "company_func.h"
79 #include "waypoint_func.h"
80 #include "window_func.h"
81 #include "tilehighlight_func.h"
82 #include "window_gui.h"
83 #include "linkgraph/linkgraph_gui.h"
84 #include "viewport_kdtree.h"
85 #include "town_kdtree.h"
86 #include "viewport_sprite_sorter.h"
87 #include "bridge_map.h"
88 #include "company_base.h"
89 #include "command_func.h"
90 #include "network/network_func.h"
91 #include "framerate_type.h"
92 #include "viewport_cmd.h"
94 #include <forward_list>
97 #include "table/strings.h"
98 #include "table/string_colours.h"
100 #include "safeguards.h"
102 Point _tile_fract_coords
;
105 ViewportSignKdtree
_viewport_sign_kdtree(&Kdtree_ViewportSignXYFunc
);
106 static int _viewport_sign_maxwidth
= 0;
109 static const int MAX_TILE_EXTENT_LEFT
= ZOOM_BASE
* TILE_PIXELS
; ///< Maximum left extent of tile relative to north corner.
110 static const int MAX_TILE_EXTENT_RIGHT
= ZOOM_BASE
* TILE_PIXELS
; ///< Maximum right extent of tile relative to north corner.
111 static const int MAX_TILE_EXTENT_TOP
= ZOOM_BASE
* MAX_BUILDING_PIXELS
; ///< Maximum top extent of tile relative to north corner (not considering bridges).
112 static const int MAX_TILE_EXTENT_BOTTOM
= ZOOM_BASE
* (TILE_PIXELS
+ 2 * TILE_HEIGHT
); ///< Maximum bottom extent of tile relative to north corner (worst case: #SLOPE_STEEP_N).
114 struct StringSpriteToDraw
{
123 struct TileSpriteToDraw
{
126 const SubSprite
*sub
; ///< only draw a rectangular part of the sprite
127 int32_t x
; ///< screen X coordinate of sprite
128 int32_t y
; ///< screen Y coordinate of sprite
131 struct ChildScreenSpriteToDraw
{
134 const SubSprite
*sub
; ///< only draw a rectangular part of the sprite
138 int next
; ///< next child to draw (-1 at the end)
141 /** Enumeration of multi-part foundations */
142 enum FoundationPart
{
143 FOUNDATION_PART_NONE
= 0xFF, ///< Neither foundation nor groundsprite drawn yet.
144 FOUNDATION_PART_NORMAL
= 0, ///< First part (normal foundation or no foundation)
145 FOUNDATION_PART_HALFTILE
= 1, ///< Second part (halftile foundation)
150 * Mode of "sprite combining"
151 * @see StartSpriteCombine
153 enum SpriteCombineMode
{
154 SPRITE_COMBINE_NONE
, ///< Every #AddSortableSpriteToDraw start its own bounding box
155 SPRITE_COMBINE_PENDING
, ///< %Sprite combining will start with the next unclipped sprite.
156 SPRITE_COMBINE_ACTIVE
, ///< %Sprite combining is active. #AddSortableSpriteToDraw outputs child sprites.
159 typedef std::vector
<TileSpriteToDraw
> TileSpriteToDrawVector
;
160 typedef std::vector
<StringSpriteToDraw
> StringSpriteToDrawVector
;
161 typedef std::vector
<ParentSpriteToDraw
> ParentSpriteToDrawVector
;
162 typedef std::vector
<ChildScreenSpriteToDraw
> ChildScreenSpriteToDrawVector
;
164 /** Data structure storing rendering information */
165 struct ViewportDrawer
{
168 StringSpriteToDrawVector string_sprites_to_draw
;
169 TileSpriteToDrawVector tile_sprites_to_draw
;
170 ParentSpriteToDrawVector parent_sprites_to_draw
;
171 ParentSpriteToSortVector parent_sprites_to_sort
; ///< Parent sprite pointer array used for sorting
172 ChildScreenSpriteToDrawVector child_screen_sprites_to_draw
;
176 SpriteCombineMode combine_sprites
; ///< Current mode of "sprite combining". @see StartSpriteCombine
178 int foundation
[FOUNDATION_PART_END
]; ///< Foundation sprites (index into parent_sprites_to_draw).
179 FoundationPart foundation_part
; ///< Currently active foundation for ground sprite drawing.
180 int *last_foundation_child
[FOUNDATION_PART_END
]; ///< Tail of ChildSprite list of the foundations. (index into child_screen_sprites_to_draw)
181 Point foundation_offset
[FOUNDATION_PART_END
]; ///< Pixel offset for ground sprites on the foundations.
184 static bool MarkViewportDirty(const Viewport
*vp
, int left
, int top
, int right
, int bottom
);
186 static ViewportDrawer _vd
;
188 TileHighlightData _thd
;
189 static TileInfo _cur_ti
;
190 bool _draw_bounding_boxes
= false;
191 bool _draw_dirty_blocks
= false;
192 uint _dirty_block_colour
= 0;
193 static VpSpriteSorter _vp_sprite_sorter
= nullptr;
195 static Point
MapXYZToViewport(const Viewport
*vp
, int x
, int y
, int z
)
197 Point p
= RemapCoords(x
, y
, z
);
198 p
.x
-= vp
->virtual_width
/ 2;
199 p
.y
-= vp
->virtual_height
/ 2;
203 void DeleteWindowViewport(Window
*w
)
206 w
->viewport
= nullptr;
210 * Initialize viewport of the window for use.
211 * @param w Window to use/display the viewport in
212 * @param x Offset of left edge of viewport with respect to left edge window \a w
213 * @param y Offset of top edge of viewport with respect to top edge window \a w
214 * @param width Width of the viewport
215 * @param height Height of the viewport
216 * @param focus Either the tile index or vehicle ID to focus.
217 * @param zoom Zoomlevel to display
219 void InitializeWindowViewport(Window
*w
, int x
, int y
,
220 int width
, int height
, std::variant
<TileIndex
, VehicleID
> focus
, ZoomLevel zoom
)
222 assert(w
->viewport
== nullptr);
224 ViewportData
*vp
= new ViewportData();
226 vp
->left
= x
+ w
->left
;
227 vp
->top
= y
+ w
->top
;
231 vp
->zoom
= static_cast<ZoomLevel
>(Clamp(zoom
, _settings_client
.gui
.zoom_min
, _settings_client
.gui
.zoom_max
));
233 vp
->virtual_width
= ScaleByZoom(width
, zoom
);
234 vp
->virtual_height
= ScaleByZoom(height
, zoom
);
238 if (std::holds_alternative
<VehicleID
>(focus
)) {
241 vp
->follow_vehicle
= std::get
<VehicleID
>(focus
);
242 veh
= Vehicle::Get(vp
->follow_vehicle
);
243 pt
= MapXYZToViewport(vp
, veh
->x_pos
, veh
->y_pos
, veh
->z_pos
);
245 TileIndex tile
= std::get
<TileIndex
>(focus
);
246 if (tile
== INVALID_TILE
) {
247 /* No tile? Use center of main viewport. */
248 const Window
*mw
= GetMainWindow();
250 /* center on same place as main window (zoom is maximum, no adjustment needed) */
251 pt
.x
= mw
->viewport
->scrollpos_x
+ mw
->viewport
->virtual_width
/ 2;
252 pt
.x
-= vp
->virtual_width
/ 2;
253 pt
.y
= mw
->viewport
->scrollpos_y
+ mw
->viewport
->virtual_height
/ 2;
254 pt
.y
-= vp
->virtual_height
/ 2;
256 x
= TileX(tile
) * TILE_SIZE
;
257 y
= TileY(tile
) * TILE_SIZE
;
258 pt
= MapXYZToViewport(vp
, x
, y
, GetSlopePixelZ(x
, y
));
260 vp
->follow_vehicle
= INVALID_VEHICLE
;
263 vp
->scrollpos_x
= pt
.x
;
264 vp
->scrollpos_y
= pt
.y
;
265 vp
->dest_scrollpos_x
= pt
.x
;
266 vp
->dest_scrollpos_y
= pt
.y
;
268 vp
->overlay
= nullptr;
271 vp
->virtual_left
= 0;
275 static Point _vp_move_offs
;
277 static void DoSetViewportPosition(Window::IteratorToFront it
, int left
, int top
, int width
, int height
)
279 for (; !it
.IsEnd(); ++it
) {
280 const Window
*w
= *it
;
281 if (left
+ width
> w
->left
&&
282 w
->left
+ w
->width
> left
&&
283 top
+ height
> w
->top
&&
284 w
->top
+ w
->height
> top
) {
286 if (left
< w
->left
) {
287 DoSetViewportPosition(it
, left
, top
, w
->left
- left
, height
);
288 DoSetViewportPosition(it
, left
+ (w
->left
- left
), top
, width
- (w
->left
- left
), height
);
292 if (left
+ width
> w
->left
+ w
->width
) {
293 DoSetViewportPosition(it
, left
, top
, (w
->left
+ w
->width
- left
), height
);
294 DoSetViewportPosition(it
, left
+ (w
->left
+ w
->width
- left
), top
, width
- (w
->left
+ w
->width
- left
), height
);
299 DoSetViewportPosition(it
, left
, top
, width
, (w
->top
- top
));
300 DoSetViewportPosition(it
, left
, top
+ (w
->top
- top
), width
, height
- (w
->top
- top
));
304 if (top
+ height
> w
->top
+ w
->height
) {
305 DoSetViewportPosition(it
, left
, top
, width
, (w
->top
+ w
->height
- top
));
306 DoSetViewportPosition(it
, left
, top
+ (w
->top
+ w
->height
- top
), width
, height
- (w
->top
+ w
->height
- top
));
315 int xo
= _vp_move_offs
.x
;
316 int yo
= _vp_move_offs
.y
;
318 if (abs(xo
) >= width
|| abs(yo
) >= height
) {
320 RedrawScreenRect(left
, top
, left
+ width
, top
+ height
);
324 GfxScroll(left
, top
, width
, height
, xo
, yo
);
327 RedrawScreenRect(left
, top
, xo
+ left
, top
+ height
);
331 RedrawScreenRect(left
+ width
+ xo
, top
, left
+ width
, top
+ height
);
336 RedrawScreenRect(left
, top
, width
+ left
, top
+ yo
);
338 RedrawScreenRect(left
, top
+ height
+ yo
, width
+ left
, top
+ height
);
343 static void SetViewportPosition(Window
*w
, int x
, int y
)
345 Viewport
*vp
= w
->viewport
;
346 int old_left
= vp
->virtual_left
;
347 int old_top
= vp
->virtual_top
;
349 int left
, top
, width
, height
;
351 vp
->virtual_left
= x
;
354 /* Viewport is bound to its left top corner, so it must be rounded down (UnScaleByZoomLower)
355 * else glitch described in FS#1412 will happen (offset by 1 pixel with zoom level > NORMAL)
357 old_left
= UnScaleByZoomLower(old_left
, vp
->zoom
);
358 old_top
= UnScaleByZoomLower(old_top
, vp
->zoom
);
359 x
= UnScaleByZoomLower(x
, vp
->zoom
);
360 y
= UnScaleByZoomLower(y
, vp
->zoom
);
365 if (old_top
== 0 && old_left
== 0) return;
367 _vp_move_offs
.x
= old_left
;
368 _vp_move_offs
.y
= old_top
;
380 i
= left
+ width
- _screen
.width
;
381 if (i
>= 0) width
-= i
;
389 i
= top
+ height
- _screen
.height
;
390 if (i
>= 0) height
-= i
;
393 Window::IteratorToFront
it(w
);
395 DoSetViewportPosition(it
, left
, top
, width
, height
);
401 * Is a xy position inside the viewport of the window?
402 * @param w Window to examine its viewport
403 * @param x X coordinate of the xy position
404 * @param y Y coordinate of the xy position
405 * @return Pointer to the viewport if the xy position is in the viewport of the window,
406 * otherwise \c nullptr is returned.
408 Viewport
*IsPtInWindowViewport(const Window
*w
, int x
, int y
)
410 Viewport
*vp
= w
->viewport
;
413 IsInsideMM(x
, vp
->left
, vp
->left
+ vp
->width
) &&
414 IsInsideMM(y
, vp
->top
, vp
->top
+ vp
->height
))
421 * Translate screen coordinate in a viewport to underlying tile coordinate.
423 * Returns exact point of the map that is visible in the given place
424 * of the viewport (3D perspective), height of tiles and foundations matter.
426 * @param vp Viewport that contains the (\a x, \a y) screen coordinate
427 * @param x Screen x coordinate, distance in pixels from the left edge of viewport frame
428 * @param y Screen y coordinate, distance in pixels from the top edge of viewport frame
429 * @param clamp_to_map Clamp the coordinate outside of the map to the closest, non-void tile within the map
430 * @return Tile coordinate or (-1, -1) if given x or y is not within viewport frame
432 Point
TranslateXYToTileCoord(const Viewport
*vp
, int x
, int y
, bool clamp_to_map
)
434 if (!IsInsideBS(x
, vp
->left
, vp
->width
) || !IsInsideBS(y
, vp
->top
, vp
->height
)) {
435 Point pt
= { -1, -1 };
439 return InverseRemapCoords2(
440 ScaleByZoom(x
- vp
->left
, vp
->zoom
) + vp
->virtual_left
,
441 ScaleByZoom(y
- vp
->top
, vp
->zoom
) + vp
->virtual_top
, clamp_to_map
);
444 /* When used for zooming, check area below current coordinates (x,y)
445 * and return the tile of the zoomed out/in position (zoom_x, zoom_y)
446 * when you just want the tile, make x = zoom_x and y = zoom_y */
447 static Point
GetTileFromScreenXY(int x
, int y
, int zoom_x
, int zoom_y
)
453 if ( (w
= FindWindowFromPt(x
, y
)) != nullptr &&
454 (vp
= IsPtInWindowViewport(w
, x
, y
)) != nullptr)
455 return TranslateXYToTileCoord(vp
, zoom_x
, zoom_y
);
461 Point
GetTileBelowCursor()
463 return GetTileFromScreenXY(_cursor
.pos
.x
, _cursor
.pos
.y
, _cursor
.pos
.x
, _cursor
.pos
.y
);
467 Point
GetTileZoomCenterWindow(bool in
, Window
* w
)
470 Viewport
*vp
= w
->viewport
;
473 x
= ((_cursor
.pos
.x
- vp
->left
) >> 1) + (vp
->width
>> 2);
474 y
= ((_cursor
.pos
.y
- vp
->top
) >> 1) + (vp
->height
>> 2);
476 x
= vp
->width
- (_cursor
.pos
.x
- vp
->left
);
477 y
= vp
->height
- (_cursor
.pos
.y
- vp
->top
);
479 /* Get the tile below the cursor and center on the zoomed-out center */
480 return GetTileFromScreenXY(_cursor
.pos
.x
, _cursor
.pos
.y
, x
+ vp
->left
, y
+ vp
->top
);
484 * Update the status of the zoom-buttons according to the zoom-level
485 * of the viewport. This will update their status and invalidate accordingly
486 * @param w Window pointer to the window that has the zoom buttons
487 * @param vp pointer to the viewport whose zoom-level the buttons represent
488 * @param widget_zoom_in widget index for window with zoom-in button
489 * @param widget_zoom_out widget index for window with zoom-out button
491 void HandleZoomMessage(Window
*w
, const Viewport
*vp
, WidgetID widget_zoom_in
, WidgetID widget_zoom_out
)
493 w
->SetWidgetDisabledState(widget_zoom_in
, vp
->zoom
<= _settings_client
.gui
.zoom_min
);
494 w
->SetWidgetDirty(widget_zoom_in
);
496 w
->SetWidgetDisabledState(widget_zoom_out
, vp
->zoom
>= _settings_client
.gui
.zoom_max
);
497 w
->SetWidgetDirty(widget_zoom_out
);
501 * Schedules a tile sprite for drawing.
503 * @param image the image to draw.
504 * @param pal the provided palette.
505 * @param x position x (world coordinates) of the sprite.
506 * @param y position y (world coordinates) of the sprite.
507 * @param z position z (world coordinates) of the sprite.
508 * @param sub Only draw a part of the sprite.
509 * @param extra_offs_x Pixel X offset for the sprite position.
510 * @param extra_offs_y Pixel Y offset for the sprite position.
512 static void AddTileSpriteToDraw(SpriteID image
, PaletteID pal
, int32_t x
, int32_t y
, int z
, const SubSprite
*sub
= nullptr, int extra_offs_x
= 0, int extra_offs_y
= 0)
514 assert((image
& SPRITE_MASK
) < MAX_SPRITES
);
516 TileSpriteToDraw
&ts
= _vd
.tile_sprites_to_draw
.emplace_back();
520 Point pt
= RemapCoords(x
, y
, z
);
521 ts
.x
= pt
.x
+ extra_offs_x
;
522 ts
.y
= pt
.y
+ extra_offs_y
;
526 * Adds a child sprite to the active foundation.
528 * The pixel offset of the sprite relative to the ParentSprite is the sum of the offset passed to OffsetGroundSprite() and extra_offs_?.
530 * @param image the image to draw.
531 * @param pal the provided palette.
532 * @param sub Only draw a part of the sprite.
533 * @param foundation_part Foundation part.
534 * @param extra_offs_x Pixel X offset for the sprite position.
535 * @param extra_offs_y Pixel Y offset for the sprite position.
537 static void AddChildSpriteToFoundation(SpriteID image
, PaletteID pal
, const SubSprite
*sub
, FoundationPart foundation_part
, int extra_offs_x
, int extra_offs_y
)
539 assert(IsInsideMM(foundation_part
, 0, FOUNDATION_PART_END
));
540 assert(_vd
.foundation
[foundation_part
] != -1);
541 Point offs
= _vd
.foundation_offset
[foundation_part
];
543 /* Change the active ChildSprite list to the one of the foundation */
544 int *old_child
= _vd
.last_child
;
545 _vd
.last_child
= _vd
.last_foundation_child
[foundation_part
];
547 AddChildSpriteScreen(image
, pal
, offs
.x
+ extra_offs_x
, offs
.y
+ extra_offs_y
, false, sub
, false, false);
549 /* Switch back to last ChildSprite list */
550 _vd
.last_child
= old_child
;
554 * Draws a ground sprite at a specific world-coordinate relative to the current tile.
555 * If the current tile is drawn on top of a foundation the sprite is added as child sprite to the "foundation"-ParentSprite.
557 * @param image the image to draw.
558 * @param pal the provided palette.
559 * @param x position x (world coordinates) of the sprite relative to current tile.
560 * @param y position y (world coordinates) of the sprite relative to current tile.
561 * @param z position z (world coordinates) of the sprite relative to current tile.
562 * @param sub Only draw a part of the sprite.
563 * @param extra_offs_x Pixel X offset for the sprite position.
564 * @param extra_offs_y Pixel Y offset for the sprite position.
566 void DrawGroundSpriteAt(SpriteID image
, PaletteID pal
, int32_t x
, int32_t y
, int z
, const SubSprite
*sub
, int extra_offs_x
, int extra_offs_y
)
568 /* Switch to first foundation part, if no foundation was drawn */
569 if (_vd
.foundation_part
== FOUNDATION_PART_NONE
) _vd
.foundation_part
= FOUNDATION_PART_NORMAL
;
571 if (_vd
.foundation
[_vd
.foundation_part
] != -1) {
572 Point pt
= RemapCoords(x
, y
, z
);
573 AddChildSpriteToFoundation(image
, pal
, sub
, _vd
.foundation_part
, pt
.x
+ extra_offs_x
* ZOOM_BASE
, pt
.y
+ extra_offs_y
* ZOOM_BASE
);
575 AddTileSpriteToDraw(image
, pal
, _cur_ti
.x
+ x
, _cur_ti
.y
+ y
, _cur_ti
.z
+ z
, sub
, extra_offs_x
* ZOOM_BASE
, extra_offs_y
* ZOOM_BASE
);
580 * Draws a ground sprite for the current tile.
581 * If the current tile is drawn on top of a foundation the sprite is added as child sprite to the "foundation"-ParentSprite.
583 * @param image the image to draw.
584 * @param pal the provided palette.
585 * @param sub Only draw a part of the sprite.
586 * @param extra_offs_x Pixel X offset for the sprite position.
587 * @param extra_offs_y Pixel Y offset for the sprite position.
589 void DrawGroundSprite(SpriteID image
, PaletteID pal
, const SubSprite
*sub
, int extra_offs_x
, int extra_offs_y
)
591 DrawGroundSpriteAt(image
, pal
, 0, 0, 0, sub
, extra_offs_x
, extra_offs_y
);
595 * Called when a foundation has been drawn for the current tile.
596 * Successive ground sprites for the current tile will be drawn as child sprites of the "foundation"-ParentSprite, not as TileSprites.
598 * @param x sprite x-offset (screen coordinates) of ground sprites relative to the "foundation"-ParentSprite.
599 * @param y sprite y-offset (screen coordinates) of ground sprites relative to the "foundation"-ParentSprite.
601 void OffsetGroundSprite(int x
, int y
)
603 /* Switch to next foundation part */
604 switch (_vd
.foundation_part
) {
605 case FOUNDATION_PART_NONE
:
606 _vd
.foundation_part
= FOUNDATION_PART_NORMAL
;
608 case FOUNDATION_PART_NORMAL
:
609 _vd
.foundation_part
= FOUNDATION_PART_HALFTILE
;
611 default: NOT_REACHED();
614 /* _vd.last_child == nullptr if foundation sprite was clipped by the viewport bounds */
615 if (_vd
.last_child
!= nullptr) _vd
.foundation
[_vd
.foundation_part
] = (uint
)_vd
.parent_sprites_to_draw
.size() - 1;
617 _vd
.foundation_offset
[_vd
.foundation_part
].x
= x
* ZOOM_BASE
;
618 _vd
.foundation_offset
[_vd
.foundation_part
].y
= y
* ZOOM_BASE
;
619 _vd
.last_foundation_child
[_vd
.foundation_part
] = _vd
.last_child
;
623 * Adds a child sprite to a parent sprite.
624 * In contrast to "AddChildSpriteScreen()" the sprite position is in world coordinates
626 * @param image the image to draw.
627 * @param pal the provided palette.
628 * @param x position x of the sprite.
629 * @param y position y of the sprite.
630 * @param z position z of the sprite.
631 * @param sub Only draw a part of the sprite.
633 static void AddCombinedSprite(SpriteID image
, PaletteID pal
, int x
, int y
, int z
, const SubSprite
*sub
)
635 Point pt
= RemapCoords(x
, y
, z
);
636 const Sprite
*spr
= GetSprite(image
& SPRITE_MASK
, SpriteType::Normal
);
638 if (pt
.x
+ spr
->x_offs
>= _vd
.dpi
.left
+ _vd
.dpi
.width
||
639 pt
.x
+ spr
->x_offs
+ spr
->width
<= _vd
.dpi
.left
||
640 pt
.y
+ spr
->y_offs
>= _vd
.dpi
.top
+ _vd
.dpi
.height
||
641 pt
.y
+ spr
->y_offs
+ spr
->height
<= _vd
.dpi
.top
)
644 const ParentSpriteToDraw
&pstd
= _vd
.parent_sprites_to_draw
.back();
645 AddChildSpriteScreen(image
, pal
, pt
.x
- pstd
.left
, pt
.y
- pstd
.top
, false, sub
, false);
649 * Draw a (transparent) sprite at given coordinates with a given bounding box.
650 * The bounding box extends from (x + bb_offset_x, y + bb_offset_y, z + bb_offset_z) to (x + w - 1, y + h - 1, z + dz - 1), both corners included.
651 * Bounding boxes with bb_offset_x == w or bb_offset_y == h or bb_offset_z == dz are allowed and produce thin slices.
653 * @note Bounding boxes are normally specified with bb_offset_x = bb_offset_y = bb_offset_z = 0. The extent of the bounding box in negative direction is
654 * defined by the sprite offset in the grf file.
655 * However if modifying the sprite offsets is not suitable (e.g. when using existing graphics), the bounding box can be tuned by bb_offset.
657 * @pre w >= bb_offset_x, h >= bb_offset_y, dz >= bb_offset_z. Else w, h or dz are ignored.
659 * @param image the image to combine and draw,
660 * @param pal the provided palette,
661 * @param x position X (world) of the sprite,
662 * @param y position Y (world) of the sprite,
663 * @param w bounding box extent towards positive X (world),
664 * @param h bounding box extent towards positive Y (world),
665 * @param dz bounding box extent towards positive Z (world),
666 * @param z position Z (world) of the sprite,
667 * @param transparent if true, switch the palette between the provided palette and the transparent palette,
668 * @param bb_offset_x bounding box extent towards negative X (world),
669 * @param bb_offset_y bounding box extent towards negative Y (world),
670 * @param bb_offset_z bounding box extent towards negative Z (world)
671 * @param sub Only draw a part of the sprite.
673 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
)
675 int32_t left
, right
, top
, bottom
;
677 assert((image
& SPRITE_MASK
) < MAX_SPRITES
);
679 /* make the sprites transparent with the right palette */
681 SetBit(image
, PALETTE_MODIFIER_TRANSPARENT
);
682 pal
= PALETTE_TO_TRANSPARENT
;
685 if (_vd
.combine_sprites
== SPRITE_COMBINE_ACTIVE
) {
686 AddCombinedSprite(image
, pal
, x
, y
, z
, sub
);
690 _vd
.last_child
= nullptr;
692 Point pt
= RemapCoords(x
, y
, z
);
693 int tmp_left
, tmp_top
, tmp_x
= pt
.x
, tmp_y
= pt
.y
;
695 /* Compute screen extents of sprite */
696 if (image
== SPR_EMPTY_BOUNDING_BOX
) {
697 left
= tmp_left
= RemapCoords(x
+ w
, y
+ bb_offset_y
, z
+ bb_offset_z
).x
;
698 right
= RemapCoords(x
+ bb_offset_x
, y
+ h
, z
+ bb_offset_z
).x
+ 1;
699 top
= tmp_top
= RemapCoords(x
+ bb_offset_x
, y
+ bb_offset_y
, z
+ dz
).y
;
700 bottom
= RemapCoords(x
+ w
, y
+ h
, z
+ bb_offset_z
).y
+ 1;
702 const Sprite
*spr
= GetSprite(image
& SPRITE_MASK
, SpriteType::Normal
);
703 left
= tmp_left
= (pt
.x
+= spr
->x_offs
);
704 right
= (pt
.x
+ spr
->width
);
705 top
= tmp_top
= (pt
.y
+= spr
->y_offs
);
706 bottom
= (pt
.y
+ spr
->height
);
709 if (_draw_bounding_boxes
&& (image
!= SPR_EMPTY_BOUNDING_BOX
)) {
710 /* Compute maximal extents of sprite and its bounding box */
711 left
= std::min(left
, RemapCoords(x
+ w
, y
+ bb_offset_y
, z
+ bb_offset_z
).x
);
712 right
= std::max(right
, RemapCoords(x
+ bb_offset_x
, y
+ h
, z
+ bb_offset_z
).x
+ 1);
713 top
= std::min(top
, RemapCoords(x
+ bb_offset_x
, y
+ bb_offset_y
, z
+ dz
).y
);
714 bottom
= std::max(bottom
, RemapCoords(x
+ w
, y
+ h
, z
+ bb_offset_z
).y
+ 1);
717 /* Do not add the sprite to the viewport, if it is outside */
718 if (left
>= _vd
.dpi
.left
+ _vd
.dpi
.width
||
719 right
<= _vd
.dpi
.left
||
720 top
>= _vd
.dpi
.top
+ _vd
.dpi
.height
||
721 bottom
<= _vd
.dpi
.top
) {
725 ParentSpriteToDraw
&ps
= _vd
.parent_sprites_to_draw
.emplace_back();
735 ps
.xmin
= x
+ bb_offset_x
;
736 ps
.xmax
= x
+ std::max(bb_offset_x
, w
) - 1;
738 ps
.ymin
= y
+ bb_offset_y
;
739 ps
.ymax
= y
+ std::max(bb_offset_y
, h
) - 1;
741 ps
.zmin
= z
+ bb_offset_z
;
742 ps
.zmax
= z
+ std::max(bb_offset_z
, dz
) - 1;
746 _vd
.last_child
= &ps
.first_child
;
748 if (_vd
.combine_sprites
== SPRITE_COMBINE_PENDING
) _vd
.combine_sprites
= SPRITE_COMBINE_ACTIVE
;
752 * Starts a block of sprites, which are "combined" into a single bounding box.
754 * Subsequent calls to #AddSortableSpriteToDraw will be drawn into the same bounding box.
755 * That is: The first sprite that is not clipped by the viewport defines the bounding box, and
756 * the following sprites will be child sprites to that one.
759 * - The drawing order is definite. No other sprites will be sorted between those of the block.
760 * - You have to provide a valid bounding box for all sprites,
761 * as you won't know which one is the first non-clipped one.
762 * Preferable you use the same bounding box for all.
763 * - You cannot use #AddChildSpriteScreen inside the block, as its result will be indefinite.
765 * The block is terminated by #EndSpriteCombine.
767 * You cannot nest "combined" blocks.
769 void StartSpriteCombine()
771 assert(_vd
.combine_sprites
== SPRITE_COMBINE_NONE
);
772 _vd
.combine_sprites
= SPRITE_COMBINE_PENDING
;
776 * Terminates a block of sprites started by #StartSpriteCombine.
777 * Take a look there for details.
779 void EndSpriteCombine()
781 assert(_vd
.combine_sprites
!= SPRITE_COMBINE_NONE
);
782 _vd
.combine_sprites
= SPRITE_COMBINE_NONE
;
786 * Check if the parameter "check" is inside the interval between
787 * begin and end, including both begin and end.
788 * @note Whether \c begin or \c end is the biggest does not matter.
789 * This method will account for that.
790 * @param begin The begin of the interval.
791 * @param end The end of the interval.
792 * @param check The value to check.
794 static bool IsInRangeInclusive(int begin
, int end
, int check
)
796 if (begin
> end
) Swap(begin
, end
);
797 return begin
<= check
&& check
<= end
;
801 * Checks whether a point is inside the selected a diagonal rectangle given by _thd.size and _thd.pos
802 * @param x The x coordinate of the point to be checked.
803 * @param y The y coordinate of the point to be checked.
804 * @return True if the point is inside the rectangle, else false.
806 bool IsInsideRotatedRectangle(int x
, int y
)
808 int dist_a
= (_thd
.size
.x
+ _thd
.size
.y
); // Rotated coordinate system for selected rectangle.
809 int dist_b
= (_thd
.size
.x
- _thd
.size
.y
); // We don't have to divide by 2. It's all relative!
810 int a
= ((x
- _thd
.pos
.x
) + (y
- _thd
.pos
.y
)); // Rotated coordinate system for the point under scrutiny.
811 int b
= ((x
- _thd
.pos
.x
) - (y
- _thd
.pos
.y
));
813 /* Check if a and b are between 0 and dist_a or dist_b respectively. */
814 return IsInRangeInclusive(dist_a
, 0, a
) && IsInRangeInclusive(dist_b
, 0, b
);
818 * Add a child sprite to a parent sprite.
820 * @param image the image to draw.
821 * @param pal the provided palette.
822 * @param x sprite x-offset (screen coordinates) relative to parent sprite.
823 * @param y sprite y-offset (screen coordinates) relative to parent sprite.
824 * @param transparent if true, switch the palette between the provided palette and the transparent palette,
825 * @param sub Only draw a part of the sprite.
826 * @param scale if true, scale offsets to base zoom level.
827 * @param relative if true, draw sprite relative to parent sprite offsets.
829 void AddChildSpriteScreen(SpriteID image
, PaletteID pal
, int x
, int y
, bool transparent
, const SubSprite
*sub
, bool scale
, bool relative
)
831 assert((image
& SPRITE_MASK
) < MAX_SPRITES
);
833 /* If the ParentSprite was clipped by the viewport bounds, do not draw the ChildSprites either */
834 if (_vd
.last_child
== nullptr) return;
836 /* make the sprites transparent with the right palette */
838 SetBit(image
, PALETTE_MODIFIER_TRANSPARENT
);
839 pal
= PALETTE_TO_TRANSPARENT
;
842 *_vd
.last_child
= (uint
)_vd
.child_screen_sprites_to_draw
.size();
844 ChildScreenSpriteToDraw
&cs
= _vd
.child_screen_sprites_to_draw
.emplace_back();
848 cs
.x
= scale
? x
* ZOOM_BASE
: x
;
849 cs
.y
= scale
? y
* ZOOM_BASE
: y
;
850 cs
.relative
= relative
;
853 /* Append the sprite to the active ChildSprite list.
854 * If the active ParentSprite is a foundation, update last_foundation_child as well.
855 * Note: ChildSprites of foundations are NOT sequential in the vector, as selection sprites are added at last. */
856 if (_vd
.last_foundation_child
[0] == _vd
.last_child
) _vd
.last_foundation_child
[0] = &cs
.next
;
857 if (_vd
.last_foundation_child
[1] == _vd
.last_child
) _vd
.last_foundation_child
[1] = &cs
.next
;
858 _vd
.last_child
= &cs
.next
;
861 static void AddStringToDraw(int x
, int y
, StringID string
, Colours colour
, uint16_t width
)
864 StringSpriteToDraw
&ss
= _vd
.string_sprites_to_draw
.emplace_back();
865 ss
.string
= GetString(string
);
866 ss
.string_id
= string
;
875 * Draws sprites between ground sprite and everything above.
877 * The sprite is either drawn as TileSprite or as ChildSprite of the active foundation.
879 * @param image the image to draw.
880 * @param pal the provided palette.
881 * @param ti TileInfo Tile that is being drawn
882 * @param z_offset Z offset relative to the groundsprite. Only used for the sprite position, not for sprite sorting.
883 * @param foundation_part Foundation part the sprite belongs to.
884 * @param extra_offs_x Pixel X offset for the sprite position.
885 * @param extra_offs_y Pixel Y offset for the sprite position.
887 static void DrawSelectionSprite(SpriteID image
, PaletteID pal
, const TileInfo
*ti
, int z_offset
, FoundationPart foundation_part
, int extra_offs_x
= 0, int extra_offs_y
= 0)
889 /* FIXME: This is not totally valid for some autorail highlights that extend over the edges of the tile. */
890 if (_vd
.foundation
[foundation_part
] == -1) {
891 /* draw on real ground */
892 AddTileSpriteToDraw(image
, pal
, ti
->x
, ti
->y
, ti
->z
+ z_offset
, nullptr, extra_offs_x
, extra_offs_y
);
894 /* draw on top of foundation */
895 AddChildSpriteToFoundation(image
, pal
, nullptr, foundation_part
, extra_offs_x
, extra_offs_y
- z_offset
* ZOOM_BASE
);
900 * Draws a selection rectangle on a tile.
902 * @param ti TileInfo Tile that is being drawn
903 * @param pal Palette to apply.
905 static void DrawTileSelectionRect(const TileInfo
*ti
, PaletteID pal
)
907 if (!IsValidTile(ti
->tile
)) return;
910 if (IsHalftileSlope(ti
->tileh
)) {
911 Corner halftile_corner
= GetHalftileSlopeCorner(ti
->tileh
);
912 SpriteID sel2
= SPR_HALFTILE_SELECTION_FLAT
+ halftile_corner
;
913 DrawSelectionSprite(sel2
, pal
, ti
, 7 + TILE_HEIGHT
, FOUNDATION_PART_HALFTILE
);
915 Corner opposite_corner
= OppositeCorner(halftile_corner
);
916 if (IsSteepSlope(ti
->tileh
)) {
917 sel
= SPR_HALFTILE_SELECTION_DOWN
;
919 sel
= ((ti
->tileh
& SlopeWithOneCornerRaised(opposite_corner
)) != 0 ? SPR_HALFTILE_SELECTION_UP
: SPR_HALFTILE_SELECTION_FLAT
);
921 sel
+= opposite_corner
;
923 sel
= SPR_SELECT_TILE
+ SlopeToSpriteOffset(ti
->tileh
);
925 DrawSelectionSprite(sel
, pal
, ti
, 7, FOUNDATION_PART_NORMAL
);
928 static bool IsPartOfAutoLine(int px
, int py
)
930 px
-= _thd
.selstart
.x
;
931 py
-= _thd
.selstart
.y
;
933 if ((_thd
.drawstyle
& HT_DRAG_MASK
) != HT_LINE
) return false;
935 switch (_thd
.drawstyle
& HT_DIR_MASK
) {
936 case HT_DIR_X
: return py
== 0; // x direction
937 case HT_DIR_Y
: return px
== 0; // y direction
938 case HT_DIR_HU
: return px
== -py
|| px
== -py
- 16; // horizontal upper
939 case HT_DIR_HL
: return px
== -py
|| px
== -py
+ 16; // horizontal lower
940 case HT_DIR_VL
: return px
== py
|| px
== py
+ 16; // vertical left
941 case HT_DIR_VR
: return px
== py
|| px
== py
- 16; // vertical right
947 /* [direction][side] */
948 static const HighLightStyle _autorail_type
[6][2] = {
949 { HT_DIR_X
, HT_DIR_X
},
950 { HT_DIR_Y
, HT_DIR_Y
},
951 { HT_DIR_HU
, HT_DIR_HL
},
952 { HT_DIR_HL
, HT_DIR_HU
},
953 { HT_DIR_VL
, HT_DIR_VR
},
954 { HT_DIR_VR
, HT_DIR_VL
}
957 #include "table/autorail.h"
960 * Draws autorail highlights.
962 * @param *ti TileInfo Tile that is being drawn
963 * @param autorail_type Offset into _AutorailTilehSprite[][]
965 static void DrawAutorailSelection(const TileInfo
*ti
, uint autorail_type
)
971 FoundationPart foundation_part
= FOUNDATION_PART_NORMAL
;
972 Slope autorail_tileh
= RemoveHalftileSlope(ti
->tileh
);
973 if (IsHalftileSlope(ti
->tileh
)) {
974 static const uint _lower_rail
[4] = { 5U, 2U, 4U, 3U };
975 Corner halftile_corner
= GetHalftileSlopeCorner(ti
->tileh
);
976 if (autorail_type
!= _lower_rail
[halftile_corner
]) {
977 foundation_part
= FOUNDATION_PART_HALFTILE
;
978 /* Here we draw the highlights of the "three-corners-raised"-slope. That looks ok to me. */
979 autorail_tileh
= SlopeWithThreeCornersRaised(OppositeCorner(halftile_corner
));
983 offset
= _AutorailTilehSprite
[autorail_tileh
][autorail_type
];
985 image
= SPR_AUTORAIL_BASE
+ offset
;
988 image
= SPR_AUTORAIL_BASE
- offset
;
989 pal
= PALETTE_SEL_TILE_RED
;
992 DrawSelectionSprite(image
, _thd
.make_square_red
? PALETTE_SEL_TILE_RED
: pal
, ti
, 7, foundation_part
);
995 enum TileHighlightType
{
1002 const Station
*_viewport_highlight_station
; ///< Currently selected station for coverage area highlight
1003 const Waypoint
*_viewport_highlight_waypoint
; ///< Currently selected waypoint for coverage area highlight
1004 const Town
*_viewport_highlight_town
; ///< Currently selected town for coverage area highlight
1007 * Get tile highlight type of coverage area for a given tile.
1008 * @param t Tile that is being drawn
1009 * @return Tile highlight type to draw
1011 static TileHighlightType
GetTileHighlightType(TileIndex t
)
1013 if (_viewport_highlight_station
!= nullptr) {
1014 if (IsTileType(t
, MP_STATION
) && GetStationIndex(t
) == _viewport_highlight_station
->index
) return THT_WHITE
;
1015 if (_viewport_highlight_station
->TileIsInCatchment(t
)) return THT_BLUE
;
1017 if (_viewport_highlight_waypoint
!= nullptr) {
1018 if (IsTileType(t
, MP_STATION
) && GetStationIndex(t
) == _viewport_highlight_waypoint
->index
) return THT_BLUE
;
1021 if (_viewport_highlight_town
!= nullptr) {
1022 if (IsTileType(t
, MP_HOUSE
)) {
1023 if (GetTownIndex(t
) == _viewport_highlight_town
->index
) {
1024 TileHighlightType type
= THT_RED
;
1025 for (const Station
*st
: _viewport_highlight_town
->stations_near
) {
1026 if (st
->owner
!= _current_company
) continue;
1027 if (st
->TileIsInCatchment(t
)) return THT_BLUE
;
1031 } else if (IsTileType(t
, MP_STATION
)) {
1032 for (const Station
*st
: _viewport_highlight_town
->stations_near
) {
1033 if (st
->owner
!= _current_company
) continue;
1034 if (GetStationIndex(t
) == st
->index
) return THT_WHITE
;
1043 * Draw tile highlight for coverage area highlight.
1044 * @param *ti TileInfo Tile that is being drawn
1045 * @param tht Highlight type to draw.
1047 static void DrawTileHighlightType(const TileInfo
*ti
, TileHighlightType tht
)
1051 case THT_NONE
: break;
1052 case THT_WHITE
: DrawTileSelectionRect(ti
, PAL_NONE
); break;
1053 case THT_BLUE
: DrawTileSelectionRect(ti
, PALETTE_SEL_TILE_BLUE
); break;
1054 case THT_RED
: DrawTileSelectionRect(ti
, PALETTE_SEL_TILE_RED
); break;
1059 * Highlights tiles insede local authority of selected towns.
1060 * @param *ti TileInfo Tile that is being drawn
1062 static void HighlightTownLocalAuthorityTiles(const TileInfo
*ti
)
1064 /* Going through cases in order of computational time. */
1066 if (_town_local_authority_kdtree
.Count() == 0) return;
1068 /* Tile belongs to town regardless of distance from town. */
1069 if (GetTileType(ti
->tile
) == MP_HOUSE
) {
1070 if (!Town::GetByTile(ti
->tile
)->show_zone
) return;
1072 DrawTileSelectionRect(ti
, PALETTE_CRASH
);
1076 /* If the closest town in the highlighted list is far, we can stop searching. */
1077 TownID tid
= _town_local_authority_kdtree
.FindNearest(TileX(ti
->tile
), TileY(ti
->tile
));
1078 Town
*closest_highlighted_town
= Town::Get(tid
);
1080 if (DistanceManhattan(ti
->tile
, closest_highlighted_town
->xy
) >= _settings_game
.economy
.dist_local_authority
) return;
1082 /* Tile is inside of the local autrhority distance of a highlighted town,
1083 but it is possible that a non-highlighted town is even closer. */
1084 Town
*closest_town
= ClosestTownFromTile(ti
->tile
, _settings_game
.economy
.dist_local_authority
);
1086 if (closest_town
->show_zone
) {
1087 DrawTileSelectionRect(ti
, PALETTE_CRASH
);
1093 * Checks if the specified tile is selected and if so draws selection using correct selectionstyle.
1094 * @param *ti TileInfo Tile that is being drawn
1096 static void DrawTileSelection(const TileInfo
*ti
)
1098 /* Highlight tiles insede local authority of selected towns. */
1099 HighlightTownLocalAuthorityTiles(ti
);
1101 /* Draw a red error square? */
1102 bool is_redsq
= _thd
.redsq
== ti
->tile
;
1103 if (is_redsq
) DrawTileSelectionRect(ti
, PALETTE_TILE_RED_PULSATING
);
1105 TileHighlightType tht
= GetTileHighlightType(ti
->tile
);
1106 DrawTileHighlightType(ti
, tht
);
1108 /* No tile selection active? */
1109 if ((_thd
.drawstyle
& HT_DRAG_MASK
) == HT_NONE
) return;
1111 if (_thd
.diagonal
) { // We're drawing a 45 degrees rotated (diagonal) rectangle
1112 if (IsInsideRotatedRectangle((int)ti
->x
, (int)ti
->y
)) goto draw_inner
;
1116 /* Inside the inner area? */
1117 if (IsInsideBS(ti
->x
, _thd
.pos
.x
, _thd
.size
.x
) &&
1118 IsInsideBS(ti
->y
, _thd
.pos
.y
, _thd
.size
.y
)) {
1120 if (_thd
.drawstyle
& HT_RECT
) {
1121 if (!is_redsq
) DrawTileSelectionRect(ti
, _thd
.make_square_red
? PALETTE_SEL_TILE_RED
: PAL_NONE
);
1122 } else if (_thd
.drawstyle
& HT_POINT
) {
1123 /* Figure out the Z coordinate for the single dot. */
1125 FoundationPart foundation_part
= FOUNDATION_PART_NORMAL
;
1126 if (ti
->tileh
& SLOPE_N
) {
1128 if (RemoveHalftileSlope(ti
->tileh
) == SLOPE_STEEP_N
) z
+= TILE_HEIGHT
;
1130 if (IsHalftileSlope(ti
->tileh
)) {
1131 Corner halftile_corner
= GetHalftileSlopeCorner(ti
->tileh
);
1132 if ((halftile_corner
== CORNER_W
) || (halftile_corner
== CORNER_E
)) z
+= TILE_HEIGHT
;
1133 if (halftile_corner
!= CORNER_S
) {
1134 foundation_part
= FOUNDATION_PART_HALFTILE
;
1135 if (IsSteepSlope(ti
->tileh
)) z
-= TILE_HEIGHT
;
1138 DrawSelectionSprite(SPR_DOT
, PAL_NONE
, ti
, z
, foundation_part
);
1139 } else if (_thd
.drawstyle
& HT_RAIL
) {
1140 /* autorail highlight piece under cursor */
1141 HighLightStyle type
= _thd
.drawstyle
& HT_DIR_MASK
;
1142 assert(type
< HT_DIR_END
);
1143 DrawAutorailSelection(ti
, _autorail_type
[type
][0]);
1144 } else if (IsPartOfAutoLine(ti
->x
, ti
->y
)) {
1145 /* autorail highlighting long line */
1146 HighLightStyle dir
= _thd
.drawstyle
& HT_DIR_MASK
;
1149 if (dir
== HT_DIR_X
|| dir
== HT_DIR_Y
) {
1152 TileIndex start
= TileVirtXY(_thd
.selstart
.x
, _thd
.selstart
.y
);
1153 side
= Delta(Delta(TileX(start
), TileX(ti
->tile
)), Delta(TileY(start
), TileY(ti
->tile
)));
1156 DrawAutorailSelection(ti
, _autorail_type
[dir
][side
]);
1161 /* Check if it's inside the outer area? */
1162 if (!is_redsq
&& (tht
== THT_NONE
|| tht
== THT_RED
) && _thd
.outersize
.x
> 0 &&
1163 IsInsideBS(ti
->x
, _thd
.pos
.x
+ _thd
.offs
.x
, _thd
.size
.x
+ _thd
.outersize
.x
) &&
1164 IsInsideBS(ti
->y
, _thd
.pos
.y
+ _thd
.offs
.y
, _thd
.size
.y
+ _thd
.outersize
.y
)) {
1165 /* Draw a blue rect. */
1166 DrawTileSelectionRect(ti
, PALETTE_SEL_TILE_BLUE
);
1172 * Returns the y coordinate in the viewport coordinate system where the given
1174 * @param tile Any tile.
1175 * @return The viewport y coordinate where the tile is painted.
1177 static int GetViewportY(Point tile
)
1179 /* Each increment in X or Y direction moves down by half a tile, i.e. TILE_PIXELS / 2. */
1180 return (tile
.y
* (int)(TILE_PIXELS
/ 2) + tile
.x
* (int)(TILE_PIXELS
/ 2) - TilePixelHeightOutsideMap(tile
.x
, tile
.y
)) << ZOOM_BASE_SHIFT
;
1184 * Add the landscape to the viewport, i.e. all ground tiles and buildings.
1186 static void ViewportAddLandscape()
1188 assert(_vd
.dpi
.top
<= _vd
.dpi
.top
+ _vd
.dpi
.height
);
1189 assert(_vd
.dpi
.left
<= _vd
.dpi
.left
+ _vd
.dpi
.width
);
1191 Point upper_left
= InverseRemapCoords(_vd
.dpi
.left
, _vd
.dpi
.top
);
1192 Point upper_right
= InverseRemapCoords(_vd
.dpi
.left
+ _vd
.dpi
.width
, _vd
.dpi
.top
);
1194 /* Transformations between tile coordinates and viewport rows/columns: See vp_column_row
1197 * x = (row - column) / 2
1198 * y = (row + column) / 2
1199 * Note: (row, columns) pairs are only valid, if they are both even or both odd.
1202 /* Columns overlap with neighbouring columns by a half tile.
1203 * - Left column is column of upper_left (rounded down) and one column to the left.
1204 * - Right column is column of upper_right (rounded up) and one column to the right.
1205 * Note: Integer-division does not round down for negative numbers, so ensure rounding with another increment/decrement.
1207 int left_column
= (upper_left
.y
- upper_left
.x
) / (int)TILE_SIZE
- 2;
1208 int right_column
= (upper_right
.y
- upper_right
.x
) / (int)TILE_SIZE
+ 2;
1210 int potential_bridge_height
= ZOOM_BASE
* TILE_HEIGHT
* _settings_game
.construction
.max_bridge_height
;
1212 /* Rows overlap with neighbouring rows by a half tile.
1213 * The first row that could possibly be visible is the row above upper_left (if it is at height 0).
1214 * Due to integer-division not rounding down for negative numbers, we need another decrement.
1216 int row
= (upper_left
.x
+ upper_left
.y
) / (int)TILE_SIZE
- 2;
1217 bool last_row
= false;
1218 for (; !last_row
; row
++) {
1220 for (int column
= left_column
; column
<= right_column
; column
++) {
1221 /* Valid row/column? */
1222 if ((row
+ column
) % 2 != 0) continue;
1225 tilecoord
.x
= (row
- column
) / 2;
1226 tilecoord
.y
= (row
+ column
) / 2;
1227 assert(column
== tilecoord
.y
- tilecoord
.x
);
1228 assert(row
== tilecoord
.y
+ tilecoord
.x
);
1231 _cur_ti
.x
= tilecoord
.x
* TILE_SIZE
;
1232 _cur_ti
.y
= tilecoord
.y
* TILE_SIZE
;
1234 if (IsInsideBS(tilecoord
.x
, 0, Map::SizeX()) && IsInsideBS(tilecoord
.y
, 0, Map::SizeY())) {
1235 /* This includes the south border at Map::MaxX / Map::MaxY. When terraforming we still draw tile selections there. */
1236 _cur_ti
.tile
= TileXY(tilecoord
.x
, tilecoord
.y
);
1237 tile_type
= GetTileType(_cur_ti
.tile
);
1239 _cur_ti
.tile
= INVALID_TILE
;
1240 tile_type
= MP_VOID
;
1243 if (tile_type
!= MP_VOID
) {
1244 /* We are inside the map => paint landscape. */
1245 std::tie(_cur_ti
.tileh
, _cur_ti
.z
) = GetTilePixelSlope(_cur_ti
.tile
);
1247 /* We are outside the map => paint black. */
1248 std::tie(_cur_ti
.tileh
, _cur_ti
.z
) = GetTilePixelSlopeOutsideMap(tilecoord
.x
, tilecoord
.y
);
1251 int viewport_y
= GetViewportY(tilecoord
);
1253 if (viewport_y
+ MAX_TILE_EXTENT_BOTTOM
< _vd
.dpi
.top
) {
1254 /* The tile in this column is not visible yet.
1255 * Tiles in other columns may be visible, but we need more rows in any case. */
1260 int min_visible_height
= viewport_y
- (_vd
.dpi
.top
+ _vd
.dpi
.height
);
1261 bool tile_visible
= min_visible_height
<= 0;
1263 if (tile_type
!= MP_VOID
) {
1264 /* Is tile with buildings visible? */
1265 if (min_visible_height
< MAX_TILE_EXTENT_TOP
) tile_visible
= true;
1267 if (IsBridgeAbove(_cur_ti
.tile
)) {
1268 /* Is the bridge visible? */
1269 TileIndex bridge_tile
= GetNorthernBridgeEnd(_cur_ti
.tile
);
1270 int bridge_height
= ZOOM_BASE
* (GetBridgePixelHeight(bridge_tile
) - TilePixelHeight(_cur_ti
.tile
));
1271 if (min_visible_height
< bridge_height
+ MAX_TILE_EXTENT_TOP
) tile_visible
= true;
1274 /* Would a higher bridge on a more southern tile be visible?
1275 * If yes, we need to loop over more rows to possibly find one. */
1276 if (min_visible_height
< potential_bridge_height
+ MAX_TILE_EXTENT_TOP
) last_row
= false;
1278 /* Outside of map. If we are on the north border of the map, there may still be a bridge visible,
1279 * so we need to loop over more rows to possibly find one. */
1280 if ((tilecoord
.x
<= 0 || tilecoord
.y
<= 0) && min_visible_height
< potential_bridge_height
+ MAX_TILE_EXTENT_TOP
) last_row
= false;
1285 _vd
.foundation_part
= FOUNDATION_PART_NONE
;
1286 _vd
.foundation
[0] = -1;
1287 _vd
.foundation
[1] = -1;
1288 _vd
.last_foundation_child
[0] = nullptr;
1289 _vd
.last_foundation_child
[1] = nullptr;
1291 _tile_type_procs
[tile_type
]->draw_tile_proc(&_cur_ti
);
1292 if (_cur_ti
.tile
!= INVALID_TILE
) DrawTileSelection(&_cur_ti
);
1299 * Add a string to draw in the viewport
1300 * @param dpi current viewport area
1301 * @param small_from Zoomlevel from when the small font should be used
1302 * @param sign sign position and dimension
1303 * @param string_normal String for normal and 2x zoom level
1304 * @param string_small String for 4x and 8x zoom level
1305 * @param string_small_shadow Shadow string for 4x and 8x zoom level; or #STR_NULL if no shadow
1306 * @param colour colour of the sign background; or INVALID_COLOUR if transparent
1308 void ViewportAddString(const DrawPixelInfo
*dpi
, ZoomLevel small_from
, const ViewportSign
*sign
, StringID string_normal
, StringID string_small
, StringID string_small_shadow
, Colours colour
)
1310 bool small
= dpi
->zoom
>= small_from
;
1312 int left
= dpi
->left
;
1314 int right
= left
+ dpi
->width
;
1315 int bottom
= top
+ dpi
->height
;
1317 int sign_height
= ScaleByZoom(WidgetDimensions::scaled
.fullbevel
.top
+ GetCharacterHeight(small
? FS_SMALL
: FS_NORMAL
) + WidgetDimensions::scaled
.fullbevel
.bottom
, dpi
->zoom
);
1318 int sign_half_width
= ScaleByZoom((small
? sign
->width_small
: sign
->width_normal
) / 2, dpi
->zoom
);
1320 if (bottom
< sign
->top
||
1321 top
> sign
->top
+ sign_height
||
1322 right
< sign
->center
- sign_half_width
||
1323 left
> sign
->center
+ sign_half_width
) {
1328 AddStringToDraw(sign
->center
- sign_half_width
, sign
->top
, string_normal
, colour
, sign
->width_normal
);
1330 int shadow_offset
= 0;
1331 if (string_small_shadow
!= STR_NULL
) {
1333 AddStringToDraw(sign
->center
- sign_half_width
+ shadow_offset
, sign
->top
, string_small_shadow
, INVALID_COLOUR
, sign
->width_small
| 0x8000);
1335 AddStringToDraw(sign
->center
- sign_half_width
, sign
->top
- shadow_offset
, string_small
, colour
, sign
->width_small
| 0x8000);
1339 static Rect
ExpandRectWithViewportSignMargins(Rect r
, ZoomLevel zoom
)
1341 const int fh
= std::max(GetCharacterHeight(FS_NORMAL
), GetCharacterHeight(FS_SMALL
));
1342 const int max_tw
= _viewport_sign_maxwidth
/ 2 + 1;
1343 const int expand_y
= ScaleByZoom(WidgetDimensions::scaled
.fullbevel
.top
+ fh
+ WidgetDimensions::scaled
.fullbevel
.bottom
, zoom
);
1344 const int expand_x
= ScaleByZoom(WidgetDimensions::scaled
.fullbevel
.left
+ max_tw
+ WidgetDimensions::scaled
.fullbevel
.right
, zoom
);
1347 r
.right
+= expand_x
;
1349 r
.bottom
+= expand_y
;
1354 static void ViewportAddKdtreeSigns(DrawPixelInfo
*dpi
)
1356 Rect search_rect
{ dpi
->left
, dpi
->top
, dpi
->left
+ dpi
->width
, dpi
->top
+ dpi
->height
};
1357 search_rect
= ExpandRectWithViewportSignMargins(search_rect
, dpi
->zoom
);
1359 bool show_stations
= HasBit(_display_opt
, DO_SHOW_STATION_NAMES
) && _game_mode
!= GM_MENU
;
1360 bool show_waypoints
= HasBit(_display_opt
, DO_SHOW_WAYPOINT_NAMES
) && _game_mode
!= GM_MENU
;
1361 bool show_towns
= HasBit(_display_opt
, DO_SHOW_TOWN_NAMES
) && _game_mode
!= GM_MENU
;
1362 bool show_signs
= HasBit(_display_opt
, DO_SHOW_SIGNS
) && !IsInvisibilitySet(TO_SIGNS
);
1363 bool show_competitors
= HasBit(_display_opt
, DO_SHOW_COMPETITOR_SIGNS
);
1365 /* Collect all the items first and draw afterwards, to ensure layering */
1366 std::vector
<const BaseStation
*> stations
;
1367 std::vector
<const Town
*> towns
;
1368 std::vector
<const Sign
*> signs
;
1370 _viewport_sign_kdtree
.FindContained(search_rect
.left
, search_rect
.top
, search_rect
.right
, search_rect
.bottom
, [&](const ViewportSignKdtreeItem
& item
) {
1371 switch (item
.type
) {
1372 case ViewportSignKdtreeItem::VKI_STATION
: {
1373 if (!show_stations
) break;
1374 const BaseStation
*st
= BaseStation::Get(item
.id
.station
);
1376 /* Don't draw if station is owned by another company and competitor station names are hidden. Stations owned by none are never ignored. */
1377 if (!show_competitors
&& _local_company
!= st
->owner
&& st
->owner
!= OWNER_NONE
) break;
1379 stations
.push_back(st
);
1383 case ViewportSignKdtreeItem::VKI_WAYPOINT
: {
1384 if (!show_waypoints
) break;
1385 const BaseStation
*st
= BaseStation::Get(item
.id
.station
);
1387 /* Don't draw if station is owned by another company and competitor station names are hidden. Stations owned by none are never ignored. */
1388 if (!show_competitors
&& _local_company
!= st
->owner
&& st
->owner
!= OWNER_NONE
) break;
1390 stations
.push_back(st
);
1394 case ViewportSignKdtreeItem::VKI_TOWN
:
1395 if (!show_towns
) break;
1396 towns
.push_back(Town::Get(item
.id
.town
));
1399 case ViewportSignKdtreeItem::VKI_SIGN
: {
1400 if (!show_signs
) break;
1401 const Sign
*si
= Sign::Get(item
.id
.sign
);
1403 /* Don't draw if sign is owned by another company and competitor signs should be hidden.
1404 * Note: It is intentional that also signs owned by OWNER_NONE are hidden. Bankrupt
1405 * companies can leave OWNER_NONE signs after them. */
1406 if (!show_competitors
&& _local_company
!= si
->owner
&& si
->owner
!= OWNER_DEITY
) break;
1408 signs
.push_back(si
);
1417 /* Layering order (bottom to top): Town names, signs, stations */
1419 for (const auto *t
: towns
) {
1420 SetDParam(0, t
->index
);
1421 SetDParam(1, t
->cache
.population
);
1422 ViewportAddString(dpi
, ZOOM_LVL_OUT_4X
, &t
->cache
.sign
,
1423 _settings_client
.gui
.population_in_label
? STR_VIEWPORT_TOWN_POP
: STR_VIEWPORT_TOWN
,
1424 STR_VIEWPORT_TOWN_TINY_WHITE
, STR_VIEWPORT_TOWN_TINY_BLACK
);
1427 /* Do not draw signs nor station names if they are set invisible */
1428 if (IsInvisibilitySet(TO_SIGNS
)) return;
1430 for (const auto *si
: signs
) {
1431 SetDParam(0, si
->index
);
1432 ViewportAddString(dpi
, ZOOM_LVL_OUT_4X
, &si
->sign
,
1434 (IsTransparencySet(TO_SIGNS
) || si
->owner
== OWNER_DEITY
) ? STR_VIEWPORT_SIGN_SMALL_WHITE
: STR_VIEWPORT_SIGN_SMALL_BLACK
, STR_NULL
,
1435 (si
->owner
== OWNER_NONE
) ? COLOUR_GREY
: (si
->owner
== OWNER_DEITY
? INVALID_COLOUR
: _company_colours
[si
->owner
]));
1438 for (const auto *st
: stations
) {
1439 SetDParam(0, st
->index
);
1440 SetDParam(1, st
->facilities
);
1441 if (Station::IsExpected(st
)) {
1443 ViewportAddString(dpi
, ZOOM_LVL_OUT_4X
, &st
->sign
,
1444 STR_VIEWPORT_STATION
, STR_VIEWPORT_STATION_TINY
, STR_NULL
,
1445 (st
->owner
== OWNER_NONE
|| !st
->IsInUse()) ? COLOUR_GREY
: _company_colours
[st
->owner
]);
1448 ViewportAddString(dpi
, ZOOM_LVL_OUT_4X
, &st
->sign
,
1449 STR_VIEWPORT_WAYPOINT
, STR_VIEWPORT_WAYPOINT_TINY
, STR_NULL
,
1450 (st
->owner
== OWNER_NONE
|| !st
->IsInUse()) ? COLOUR_GREY
: _company_colours
[st
->owner
]);
1457 * Update the position of the viewport sign.
1458 * @param center the (preferred) center of the viewport sign
1459 * @param top the new top of the sign
1460 * @param str the string to show in the sign
1461 * @param str_small the string to show when zoomed out. STR_NULL means same as \a str
1463 void ViewportSign::UpdatePosition(int center
, int top
, StringID str
, StringID str_small
)
1465 if (this->width_normal
!= 0) this->MarkDirty();
1469 std::string name
= GetString(str
);
1470 this->width_normal
= WidgetDimensions::scaled
.fullbevel
.left
+ Align(GetStringBoundingBox(name
).width
, 2) + WidgetDimensions::scaled
.fullbevel
.right
;
1471 this->center
= center
;
1473 /* zoomed out version */
1474 if (str_small
!= STR_NULL
) {
1475 name
= GetString(str_small
);
1477 this->width_small
= WidgetDimensions::scaled
.fullbevel
.left
+ Align(GetStringBoundingBox(name
, FS_SMALL
).width
, 2) + WidgetDimensions::scaled
.fullbevel
.right
;
1483 * Mark the sign dirty in all viewports.
1484 * @param maxzoom Maximum %ZoomLevel at which the text is visible.
1488 void ViewportSign::MarkDirty(ZoomLevel maxzoom
) const
1490 Rect zoomlevels
[ZOOM_LVL_END
];
1492 /* We don't know which size will be drawn, so mark the largest area dirty. */
1493 const uint half_width
= std::max(this->width_normal
, this->width_small
) / 2 + 1;
1494 const uint height
= WidgetDimensions::scaled
.fullbevel
.top
+ std::max(GetCharacterHeight(FS_NORMAL
), GetCharacterHeight(FS_SMALL
)) + WidgetDimensions::scaled
.fullbevel
.bottom
+ 1;
1496 for (ZoomLevel zoom
= ZOOM_LVL_BEGIN
; zoom
!= ZOOM_LVL_END
; zoom
++) {
1497 /* FIXME: This doesn't switch to width_small when appropriate. */
1498 zoomlevels
[zoom
].left
= this->center
- ScaleByZoom(half_width
, zoom
);
1499 zoomlevels
[zoom
].top
= this->top
- ScaleByZoom(1, zoom
);
1500 zoomlevels
[zoom
].right
= this->center
+ ScaleByZoom(half_width
, zoom
);
1501 zoomlevels
[zoom
].bottom
= this->top
+ ScaleByZoom(height
, zoom
);
1504 for (const Window
*w
: Window::Iterate()) {
1505 Viewport
*vp
= w
->viewport
;
1506 if (vp
!= nullptr && vp
->zoom
<= maxzoom
) {
1507 assert(vp
->width
!= 0);
1508 Rect
&zl
= zoomlevels
[vp
->zoom
];
1509 MarkViewportDirty(vp
, zl
.left
, zl
.top
, zl
.right
, zl
.bottom
);
1514 static void ViewportDrawTileSprites(const TileSpriteToDrawVector
*tstdv
)
1516 for (const TileSpriteToDraw
&ts
: *tstdv
) {
1517 DrawSpriteViewport(ts
.image
, ts
.pal
, ts
.x
, ts
.y
, ts
.sub
);
1521 /** This fallback sprite checker always exists. */
1522 static bool ViewportSortParentSpritesChecker()
1527 /** Sort parent sprites pointer array replicating the way original sorter did it. */
1528 static void ViewportSortParentSprites(ParentSpriteToSortVector
*psdv
)
1530 if (psdv
->size() < 2) return;
1532 /* We rely on sprites being, for the most part, already ordered.
1533 * So we don't need to move many of them and can keep track of their
1534 * order efficiently by using stack. We always move sprites to the front
1535 * of the current position, i.e. to the top of the stack.
1536 * Also use special constants to indicate sorting state without
1537 * adding extra fields to ParentSpriteToDraw structure.
1539 const uint32_t ORDER_COMPARED
= UINT32_MAX
; // Sprite was compared but we still need to compare the ones preceding it
1540 const uint32_t ORDER_RETURNED
= UINT32_MAX
- 1; // Makr sorted sprite in case there are other occurrences of it in the stack
1541 std::stack
<ParentSpriteToDraw
*> sprite_order
;
1542 uint32_t next_order
= 0;
1544 std::forward_list
<std::pair
<int64_t, ParentSpriteToDraw
*>> sprite_list
; // We store sprites in a list sorted by xmin+ymin
1546 /* Initialize sprite list and order. */
1547 for (auto p
= psdv
->rbegin(); p
!= psdv
->rend(); p
++) {
1548 sprite_list
.emplace_front((*p
)->xmin
+ (*p
)->ymin
, *p
);
1549 sprite_order
.push(*p
);
1550 (*p
)->order
= next_order
++;
1555 std::vector
<ParentSpriteToDraw
*> preceding
; // Temporarily stores sprites that precede current and their position in the list
1556 auto preceding_prev
= sprite_list
.begin(); // Store iterator in case we need to delete a single preciding sprite
1557 auto out
= psdv
->begin(); // Iterator to output sorted sprites
1559 while (!sprite_order
.empty()) {
1561 auto s
= sprite_order
.top();
1564 /* Sprite is already sorted, ignore it. */
1565 if (s
->order
== ORDER_RETURNED
) continue;
1567 /* Sprite was already compared, just need to output it. */
1568 if (s
->order
== ORDER_COMPARED
) {
1570 s
->order
= ORDER_RETURNED
;
1576 /* We only need sprites with xmin <= s->xmax && ymin <= s->ymax && zmin <= s->zmax
1577 * So by iterating sprites with xmin + ymin <= s->xmax + s->ymax
1578 * we get all we need and some more that we filter out later.
1579 * We don't include zmin into the sum as there are usually more neighbors on x and y than z
1580 * so including it will actually increase the amount of false positives.
1581 * Also min coordinates can be > max so using max(xmin, xmax) + max(ymin, ymax)
1582 * to ensure that we iterate the current sprite as we need to remove it from the list.
1584 auto ssum
= std::max(s
->xmax
, s
->xmin
) + std::max(s
->ymax
, s
->ymin
);
1585 auto prev
= sprite_list
.before_begin();
1586 auto x
= sprite_list
.begin();
1587 while (x
!= sprite_list
.end() && ((*x
).first
<= ssum
)) {
1588 auto p
= (*x
).second
;
1590 /* We found the current sprite, remove it and move on. */
1591 x
= sprite_list
.erase_after(prev
);
1598 if (s
->xmax
< p
->xmin
|| s
->ymax
< p
->ymin
|| s
->zmax
< p
->zmin
) continue;
1599 if (s
->xmin
<= p
->xmax
&& // overlap in X?
1600 s
->ymin
<= p
->ymax
&& // overlap in Y?
1601 s
->zmin
<= p
->zmax
) { // overlap in Z?
1602 if (s
->xmin
+ s
->xmax
+ s
->ymin
+ s
->ymax
+ s
->zmin
+ s
->zmax
<=
1603 p
->xmin
+ p
->xmax
+ p
->ymin
+ p
->ymax
+ p
->zmin
+ p
->zmax
) {
1607 preceding
.push_back(p
);
1608 preceding_prev
= p_prev
;
1611 if (preceding
.empty()) {
1612 /* No preceding sprites, add current one to the output */
1614 s
->order
= ORDER_RETURNED
;
1618 /* Optimization for the case when we only have 1 sprite to move. */
1619 if (preceding
.size() == 1) {
1620 auto p
= preceding
[0];
1621 /* We can only output the preceding sprite if there can't be any other sprites preceding it. */
1622 if (p
->xmax
<= s
->xmax
&& p
->ymax
<= s
->ymax
&& p
->zmax
<= s
->zmax
) {
1623 p
->order
= ORDER_RETURNED
;
1624 s
->order
= ORDER_RETURNED
;
1625 sprite_list
.erase_after(preceding_prev
);
1632 /* Sort all preceding sprites by order and assign new orders in reverse (as original sorter did). */
1633 std::sort(preceding
.begin(), preceding
.end(), [](const ParentSpriteToDraw
*a
, const ParentSpriteToDraw
*b
) {
1634 return a
->order
> b
->order
;
1637 s
->order
= ORDER_COMPARED
;
1638 sprite_order
.push(s
); // Still need to output so push it back for now
1640 for (auto p
: preceding
) {
1641 p
->order
= next_order
++;
1642 sprite_order
.push(p
);
1648 static void ViewportDrawParentSprites(const ParentSpriteToSortVector
*psd
, const ChildScreenSpriteToDrawVector
*csstdv
)
1650 for (const ParentSpriteToDraw
*ps
: *psd
) {
1651 if (ps
->image
!= SPR_EMPTY_BOUNDING_BOX
) DrawSpriteViewport(ps
->image
, ps
->pal
, ps
->x
, ps
->y
, ps
->sub
);
1653 int child_idx
= ps
->first_child
;
1654 while (child_idx
>= 0) {
1655 const ChildScreenSpriteToDraw
*cs
= csstdv
->data() + child_idx
;
1656 child_idx
= cs
->next
;
1658 DrawSpriteViewport(cs
->image
, cs
->pal
, ps
->left
+ cs
->x
, ps
->top
+ cs
->y
, cs
->sub
);
1660 DrawSpriteViewport(cs
->image
, cs
->pal
, ps
->x
+ cs
->x
, ps
->y
+ cs
->y
, cs
->sub
);
1667 * Draws the bounding boxes of all ParentSprites
1668 * @param psd Array of ParentSprites
1670 static void ViewportDrawBoundingBoxes(const ParentSpriteToSortVector
*psd
)
1672 for (const ParentSpriteToDraw
*ps
: *psd
) {
1673 Point pt1
= RemapCoords(ps
->xmax
+ 1, ps
->ymax
+ 1, ps
->zmax
+ 1); // top front corner
1674 Point pt2
= RemapCoords(ps
->xmin
, ps
->ymax
+ 1, ps
->zmax
+ 1); // top left corner
1675 Point pt3
= RemapCoords(ps
->xmax
+ 1, ps
->ymin
, ps
->zmax
+ 1); // top right corner
1676 Point pt4
= RemapCoords(ps
->xmax
+ 1, ps
->ymax
+ 1, ps
->zmin
); // bottom front corner
1678 DrawBox( pt1
.x
, pt1
.y
,
1679 pt2
.x
- pt1
.x
, pt2
.y
- pt1
.y
,
1680 pt3
.x
- pt1
.x
, pt3
.y
- pt1
.y
,
1681 pt4
.x
- pt1
.x
, pt4
.y
- pt1
.y
);
1686 * Draw/colour the blocks that have been redrawn.
1688 static void ViewportDrawDirtyBlocks()
1690 Blitter
*blitter
= BlitterFactory::GetCurrentBlitter();
1691 const DrawPixelInfo
*dpi
= _cur_dpi
;
1693 int right
= UnScaleByZoom(dpi
->width
, dpi
->zoom
);
1694 int bottom
= UnScaleByZoom(dpi
->height
, dpi
->zoom
);
1696 int colour
= _string_colourmap
[_dirty_block_colour
& 0xF];
1700 uint8_t bo
= UnScaleByZoom(dpi
->left
+ dpi
->top
, dpi
->zoom
) & 1;
1702 for (int i
= (bo
^= 1); i
< right
; i
+= 2) blitter
->SetPixel(dst
, i
, 0, (uint8_t)colour
);
1703 dst
= blitter
->MoveTo(dst
, 0, 1);
1704 } while (--bottom
> 0);
1707 static void ViewportDrawStrings(ZoomLevel zoom
, const StringSpriteToDrawVector
*sstdv
)
1709 for (const StringSpriteToDraw
&ss
: *sstdv
) {
1710 TextColour colour
= TC_BLACK
;
1711 bool small
= HasBit(ss
.width
, 15);
1712 int w
= GB(ss
.width
, 0, 15);
1713 int x
= UnScaleByZoom(ss
.x
, zoom
);
1714 int y
= UnScaleByZoom(ss
.y
, zoom
);
1715 int h
= WidgetDimensions::scaled
.fullbevel
.top
+ GetCharacterHeight(small
? FS_SMALL
: FS_NORMAL
) + WidgetDimensions::scaled
.fullbevel
.bottom
;
1717 if (ss
.colour
!= INVALID_COLOUR
) {
1718 if (IsTransparencySet(TO_SIGNS
) && ss
.string_id
!= STR_WHITE_SIGN
) {
1719 /* Don't draw the rectangle.
1720 * Real colours need the TC_IS_PALETTE_COLOUR flag.
1721 * Otherwise colours from _string_colourmap are assumed. */
1722 colour
= (TextColour
)GetColourGradient(ss
.colour
, SHADE_LIGHTER
) | TC_IS_PALETTE_COLOUR
;
1724 /* Draw the rectangle if 'transparent station signs' is off,
1725 * or if we are drawing a general text sign (STR_WHITE_SIGN). */
1727 x
, y
, x
+ w
- 1, y
+ h
- 1, ss
.colour
,
1728 IsTransparencySet(TO_SIGNS
) ? FR_TRANSPARENT
: FR_NONE
1733 DrawString(x
+ WidgetDimensions::scaled
.fullbevel
.left
, x
+ w
- 1 - WidgetDimensions::scaled
.fullbevel
.right
, y
+ WidgetDimensions::scaled
.fullbevel
.top
, ss
.string
, colour
, SA_HOR_CENTER
, false, small
? FS_SMALL
: FS_NORMAL
);
1737 void ViewportDoDraw(const Viewport
*vp
, int left
, int top
, int right
, int bottom
)
1739 _vd
.dpi
.zoom
= vp
->zoom
;
1740 int mask
= ScaleByZoom(-1, vp
->zoom
);
1742 _vd
.combine_sprites
= SPRITE_COMBINE_NONE
;
1744 _vd
.dpi
.width
= (right
- left
) & mask
;
1745 _vd
.dpi
.height
= (bottom
- top
) & mask
;
1746 _vd
.dpi
.left
= left
& mask
;
1747 _vd
.dpi
.top
= top
& mask
;
1748 _vd
.dpi
.pitch
= _cur_dpi
->pitch
;
1749 _vd
.last_child
= nullptr;
1751 int x
= UnScaleByZoom(_vd
.dpi
.left
- (vp
->virtual_left
& mask
), vp
->zoom
) + vp
->left
;
1752 int y
= UnScaleByZoom(_vd
.dpi
.top
- (vp
->virtual_top
& mask
), vp
->zoom
) + vp
->top
;
1754 _vd
.dpi
.dst_ptr
= BlitterFactory::GetCurrentBlitter()->MoveTo(_cur_dpi
->dst_ptr
, x
- _cur_dpi
->left
, y
- _cur_dpi
->top
);
1755 AutoRestoreBackup
dpi_backup(_cur_dpi
, &_vd
.dpi
);
1757 ViewportAddLandscape();
1758 ViewportAddVehicles(&_vd
.dpi
);
1760 ViewportAddKdtreeSigns(&_vd
.dpi
);
1762 DrawTextEffects(&_vd
.dpi
);
1764 if (!_vd
.tile_sprites_to_draw
.empty()) ViewportDrawTileSprites(&_vd
.tile_sprites_to_draw
);
1766 for (auto &psd
: _vd
.parent_sprites_to_draw
) {
1767 _vd
.parent_sprites_to_sort
.push_back(&psd
);
1770 _vp_sprite_sorter(&_vd
.parent_sprites_to_sort
);
1771 ViewportDrawParentSprites(&_vd
.parent_sprites_to_sort
, &_vd
.child_screen_sprites_to_draw
);
1773 if (_draw_bounding_boxes
) ViewportDrawBoundingBoxes(&_vd
.parent_sprites_to_sort
);
1774 if (_draw_dirty_blocks
) ViewportDrawDirtyBlocks();
1776 DrawPixelInfo dp
= _vd
.dpi
;
1777 ZoomLevel zoom
= _vd
.dpi
.zoom
;
1778 dp
.zoom
= ZOOM_LVL_MIN
;
1779 dp
.width
= UnScaleByZoom(dp
.width
, zoom
);
1780 dp
.height
= UnScaleByZoom(dp
.height
, zoom
);
1783 if (vp
->overlay
!= nullptr && vp
->overlay
->GetCargoMask() != 0 && vp
->overlay
->GetCompanyMask() != 0) {
1784 /* translate to window coordinates */
1787 vp
->overlay
->Draw(&dp
);
1790 if (!_vd
.string_sprites_to_draw
.empty()) {
1791 /* translate to world coordinates */
1792 dp
.left
= UnScaleByZoom(_vd
.dpi
.left
, zoom
);
1793 dp
.top
= UnScaleByZoom(_vd
.dpi
.top
, zoom
);
1794 ViewportDrawStrings(zoom
, &_vd
.string_sprites_to_draw
);
1797 _vd
.string_sprites_to_draw
.clear();
1798 _vd
.tile_sprites_to_draw
.clear();
1799 _vd
.parent_sprites_to_draw
.clear();
1800 _vd
.parent_sprites_to_sort
.clear();
1801 _vd
.child_screen_sprites_to_draw
.clear();
1804 static inline void ViewportDraw(const Viewport
*vp
, int left
, int top
, int right
, int bottom
)
1806 if (right
<= vp
->left
|| bottom
<= vp
->top
) return;
1808 if (left
>= vp
->left
+ vp
->width
) return;
1810 if (left
< vp
->left
) left
= vp
->left
;
1811 if (right
> vp
->left
+ vp
->width
) right
= vp
->left
+ vp
->width
;
1813 if (top
>= vp
->top
+ vp
->height
) return;
1815 if (top
< vp
->top
) top
= vp
->top
;
1816 if (bottom
> vp
->top
+ vp
->height
) bottom
= vp
->top
+ vp
->height
;
1819 ScaleByZoom(left
- vp
->left
, vp
->zoom
) + vp
->virtual_left
,
1820 ScaleByZoom(top
- vp
->top
, vp
->zoom
) + vp
->virtual_top
,
1821 ScaleByZoom(right
- vp
->left
, vp
->zoom
) + vp
->virtual_left
,
1822 ScaleByZoom(bottom
- vp
->top
, vp
->zoom
) + vp
->virtual_top
1827 * Draw the viewport of this window.
1829 void Window::DrawViewport() const
1831 PerformanceAccumulator
framerate(PFE_DRAWWORLD
);
1833 DrawPixelInfo
*dpi
= _cur_dpi
;
1835 dpi
->left
+= this->left
;
1836 dpi
->top
+= this->top
;
1838 ViewportDraw(this->viewport
, dpi
->left
, dpi
->top
, dpi
->left
+ dpi
->width
, dpi
->top
+ dpi
->height
);
1840 dpi
->left
-= this->left
;
1841 dpi
->top
-= this->top
;
1845 * Ensure that a given viewport has a valid scroll position.
1847 * There must be a visible piece of the map in the center of the viewport.
1848 * If there isn't, the viewport will be scrolled to nearest such location.
1850 * @param vp The viewport.
1851 * @param[in,out] scroll_x Viewport X scroll.
1852 * @param[in,out] scroll_y Viewport Y scroll.
1854 static inline void ClampViewportToMap(const Viewport
*vp
, int *scroll_x
, int *scroll_y
)
1856 /* Centre of the viewport is hot spot. */
1858 *scroll_x
+ vp
->virtual_width
/ 2,
1859 *scroll_y
+ vp
->virtual_height
/ 2
1862 /* Find nearest tile that is within borders of the map. */
1864 pt
= InverseRemapCoords2(pt
.x
, pt
.y
, true, &clamped
);
1867 /* Convert back to viewport coordinates and remove centering. */
1868 pt
= RemapCoords2(pt
.x
, pt
.y
);
1869 *scroll_x
= pt
.x
- vp
->virtual_width
/ 2;
1870 *scroll_y
= pt
.y
- vp
->virtual_height
/ 2;
1875 * Clamp the smooth scroll to a maxmimum speed and distance based on time elapsed.
1877 * Every 30ms, we move 1/4th of the distance, to give a smooth movement experience.
1878 * But we never go over the max_scroll speed.
1880 * @param delta_ms Time elapsed since last update.
1881 * @param delta_hi The distance to move in highest dimension (can't be zero).
1882 * @param delta_lo The distance to move in lowest dimension.
1883 * @param[out] delta_hi_clamped The clamped distance to move in highest dimension.
1884 * @param[out] delta_lo_clamped The clamped distance to move in lowest dimension.
1886 static void ClampSmoothScroll(uint32_t delta_ms
, int64_t delta_hi
, int64_t delta_lo
, int &delta_hi_clamped
, int &delta_lo_clamped
)
1888 /** A tile is 64 pixels in width at 1x zoom; viewport coordinates are in 4x zoom. */
1889 constexpr int PIXELS_PER_TILE
= TILE_PIXELS
* 2 * ZOOM_BASE
;
1891 assert(delta_hi
!= 0);
1893 /* Move at most 75% of the distance every 30ms, for a smooth experience */
1894 int64_t delta_left
= delta_hi
* std::pow(0.75, delta_ms
/ 30.0);
1895 /* Move never more than 16 tiles per 30ms. */
1896 int max_scroll
= Map::ScaleBySize1D(16 * PIXELS_PER_TILE
* delta_ms
/ 30);
1898 /* We never go over the max_scroll speed. */
1899 delta_hi_clamped
= Clamp(delta_hi
- delta_left
, -max_scroll
, max_scroll
);
1900 /* The lower delta is in ratio of the higher delta, so we keep going straight at the destination. */
1901 delta_lo_clamped
= delta_lo
* delta_hi_clamped
/ delta_hi
;
1903 /* Ensure we always move (delta_hi can't be zero). */
1904 if (delta_hi_clamped
== 0) {
1905 delta_hi_clamped
= delta_hi
> 0 ? 1 : -1;
1910 * Update the viewport position being displayed.
1911 * @param w %Window owning the viewport.
1913 void UpdateViewportPosition(Window
*w
, uint32_t delta_ms
)
1915 const Viewport
*vp
= w
->viewport
;
1917 if (w
->viewport
->follow_vehicle
!= INVALID_VEHICLE
) {
1918 const Vehicle
*veh
= Vehicle::Get(w
->viewport
->follow_vehicle
);
1919 Point pt
= MapXYZToViewport(vp
, veh
->x_pos
, veh
->y_pos
, veh
->z_pos
);
1921 w
->viewport
->scrollpos_x
= pt
.x
;
1922 w
->viewport
->scrollpos_y
= pt
.y
;
1923 SetViewportPosition(w
, pt
.x
, pt
.y
);
1925 /* Ensure the destination location is within the map */
1926 ClampViewportToMap(vp
, &w
->viewport
->dest_scrollpos_x
, &w
->viewport
->dest_scrollpos_y
);
1928 int delta_x
= w
->viewport
->dest_scrollpos_x
- w
->viewport
->scrollpos_x
;
1929 int delta_y
= w
->viewport
->dest_scrollpos_y
- w
->viewport
->scrollpos_y
;
1931 int current_x
= w
->viewport
->scrollpos_x
;
1932 int current_y
= w
->viewport
->scrollpos_y
;
1934 bool update_overlay
= false;
1935 if (delta_x
!= 0 || delta_y
!= 0) {
1936 if (_settings_client
.gui
.smooth_scroll
) {
1937 int delta_x_clamped
;
1938 int delta_y_clamped
;
1940 if (abs(delta_x
) > abs(delta_y
)) {
1941 ClampSmoothScroll(delta_ms
, delta_x
, delta_y
, delta_x_clamped
, delta_y_clamped
);
1943 ClampSmoothScroll(delta_ms
, delta_y
, delta_x
, delta_y_clamped
, delta_x_clamped
);
1946 w
->viewport
->scrollpos_x
+= delta_x_clamped
;
1947 w
->viewport
->scrollpos_y
+= delta_y_clamped
;
1949 w
->viewport
->scrollpos_x
= w
->viewport
->dest_scrollpos_x
;
1950 w
->viewport
->scrollpos_y
= w
->viewport
->dest_scrollpos_y
;
1952 update_overlay
= (w
->viewport
->scrollpos_x
== w
->viewport
->dest_scrollpos_x
&&
1953 w
->viewport
->scrollpos_y
== w
->viewport
->dest_scrollpos_y
);
1956 ClampViewportToMap(vp
, &w
->viewport
->scrollpos_x
, &w
->viewport
->scrollpos_y
);
1958 /* When moving small amounts around the border we can get stuck, and
1959 * not actually move. In those cases, teleport to the destination. */
1960 if ((delta_x
!= 0 || delta_y
!= 0) && current_x
== w
->viewport
->scrollpos_x
&& current_y
== w
->viewport
->scrollpos_y
) {
1961 w
->viewport
->scrollpos_x
= w
->viewport
->dest_scrollpos_x
;
1962 w
->viewport
->scrollpos_y
= w
->viewport
->dest_scrollpos_y
;
1965 SetViewportPosition(w
, w
->viewport
->scrollpos_x
, w
->viewport
->scrollpos_y
);
1966 if (update_overlay
) RebuildViewportOverlay(w
);
1971 * Marks a viewport as dirty for repaint if it displays (a part of) the area the needs to be repainted.
1972 * @param vp The viewport to mark as dirty
1973 * @param left Left edge of area to repaint
1974 * @param top Top edge of area to repaint
1975 * @param right Right edge of area to repaint
1976 * @param bottom Bottom edge of area to repaint
1977 * @return true if the viewport contains a dirty block
1980 static bool MarkViewportDirty(const Viewport
*vp
, int left
, int top
, int right
, int bottom
)
1982 /* Rounding wrt. zoom-out level */
1983 right
+= (1 << vp
->zoom
) - 1;
1984 bottom
+= (1 << vp
->zoom
) - 1;
1986 right
-= vp
->virtual_left
;
1987 if (right
<= 0) return false;
1989 bottom
-= vp
->virtual_top
;
1990 if (bottom
<= 0) return false;
1992 left
= std::max(0, left
- vp
->virtual_left
);
1994 if (left
>= vp
->virtual_width
) return false;
1996 top
= std::max(0, top
- vp
->virtual_top
);
1998 if (top
>= vp
->virtual_height
) return false;
2001 UnScaleByZoomLower(left
, vp
->zoom
) + vp
->left
,
2002 UnScaleByZoomLower(top
, vp
->zoom
) + vp
->top
,
2003 UnScaleByZoom(right
, vp
->zoom
) + vp
->left
+ 1,
2004 UnScaleByZoom(bottom
, vp
->zoom
) + vp
->top
+ 1
2011 * Mark all viewports that display an area as dirty (in need of repaint).
2012 * @param left Left edge of area to repaint. (viewport coordinates, that is wrt. #ZOOM_LVL_MIN)
2013 * @param top Top edge of area to repaint. (viewport coordinates, that is wrt. #ZOOM_LVL_MIN)
2014 * @param right Right edge of area to repaint. (viewport coordinates, that is wrt. #ZOOM_LVL_MIN)
2015 * @param bottom Bottom edge of area to repaint. (viewport coordinates, that is wrt. #ZOOM_LVL_MIN)
2016 * @return true if at least one viewport has a dirty block
2019 bool MarkAllViewportsDirty(int left
, int top
, int right
, int bottom
)
2023 for (const Window
*w
: Window::Iterate()) {
2024 Viewport
*vp
= w
->viewport
;
2025 if (vp
!= nullptr) {
2026 assert(vp
->width
!= 0);
2027 if (MarkViewportDirty(vp
, left
, top
, right
, bottom
)) dirty
= true;
2034 void ConstrainAllViewportsZoom()
2036 for (Window
*w
: Window::Iterate()) {
2037 if (w
->viewport
== nullptr) continue;
2039 ZoomLevel zoom
= static_cast<ZoomLevel
>(Clamp(w
->viewport
->zoom
, _settings_client
.gui
.zoom_min
, _settings_client
.gui
.zoom_max
));
2040 if (zoom
!= w
->viewport
->zoom
) {
2041 while (w
->viewport
->zoom
< zoom
) DoZoomInOutWindow(ZOOM_OUT
, w
);
2042 while (w
->viewport
->zoom
> zoom
) DoZoomInOutWindow(ZOOM_IN
, w
);
2048 * Mark a tile given by its index dirty for repaint.
2049 * @param tile The tile to mark dirty.
2050 * @param bridge_level_offset Height of bridge on tile to also mark dirty. (Height level relative to north corner.)
2051 * @param tile_height_override Height of the tile (#TileHeight).
2054 void MarkTileDirtyByTile(TileIndex tile
, int bridge_level_offset
, int tile_height_override
)
2056 Point pt
= RemapCoords(TileX(tile
) * TILE_SIZE
, TileY(tile
) * TILE_SIZE
, tile_height_override
* TILE_HEIGHT
);
2057 MarkAllViewportsDirty(
2058 pt
.x
- MAX_TILE_EXTENT_LEFT
,
2059 pt
.y
- MAX_TILE_EXTENT_TOP
- ZOOM_BASE
* TILE_HEIGHT
* bridge_level_offset
,
2060 pt
.x
+ MAX_TILE_EXTENT_RIGHT
,
2061 pt
.y
+ MAX_TILE_EXTENT_BOTTOM
);
2065 * Marks the selected tiles as dirty.
2067 * This function marks the selected tiles as dirty for repaint
2071 static void SetSelectionTilesDirty()
2073 int x_size
= _thd
.size
.x
;
2074 int y_size
= _thd
.size
.y
;
2076 if (!_thd
.diagonal
) { // Selecting in a straight rectangle (or a single square)
2077 int x_start
= _thd
.pos
.x
;
2078 int y_start
= _thd
.pos
.y
;
2080 if (_thd
.outersize
.x
!= 0) {
2081 x_size
+= _thd
.outersize
.x
;
2082 x_start
+= _thd
.offs
.x
;
2083 y_size
+= _thd
.outersize
.y
;
2084 y_start
+= _thd
.offs
.y
;
2087 x_size
-= TILE_SIZE
;
2088 y_size
-= TILE_SIZE
;
2090 assert(x_size
>= 0);
2091 assert(y_size
>= 0);
2093 int x_end
= Clamp(x_start
+ x_size
, 0, Map::SizeX() * TILE_SIZE
- TILE_SIZE
);
2094 int y_end
= Clamp(y_start
+ y_size
, 0, Map::SizeY() * TILE_SIZE
- TILE_SIZE
);
2096 x_start
= Clamp(x_start
, 0, Map::SizeX() * TILE_SIZE
- TILE_SIZE
);
2097 y_start
= Clamp(y_start
, 0, Map::SizeY() * TILE_SIZE
- TILE_SIZE
);
2099 /* make sure everything is multiple of TILE_SIZE */
2100 assert((x_end
| y_end
| x_start
| y_start
) % TILE_SIZE
== 0);
2103 * Suppose we have to mark dirty rectangle of 3x4 tiles:
2110 * This algorithm marks dirty columns of tiles, so it is done in 3+4-1 steps:
2120 int top_x
= x_end
; // coordinates of top dirty tile
2121 int top_y
= y_start
;
2122 int bot_x
= top_x
; // coordinates of bottom dirty tile
2126 /* topmost dirty point */
2127 TileIndex top_tile
= TileVirtXY(top_x
, top_y
);
2128 Point top
= RemapCoords(top_x
, top_y
, GetTileMaxPixelZ(top_tile
));
2130 /* bottommost point */
2131 TileIndex bottom_tile
= TileVirtXY(bot_x
, bot_y
);
2132 Point bot
= RemapCoords(bot_x
+ TILE_SIZE
, bot_y
+ TILE_SIZE
, GetTilePixelZ(bottom_tile
)); // bottommost point
2134 /* the 'x' coordinate of 'top' and 'bot' is the same (and always in the same distance from tile middle),
2135 * tile height/slope affects only the 'y' on-screen coordinate! */
2137 int l
= top
.x
- TILE_PIXELS
* ZOOM_BASE
; // 'x' coordinate of left side of the dirty rectangle
2138 int t
= top
.y
; // 'y' coordinate of top side of the dirty rectangle
2139 int r
= top
.x
+ TILE_PIXELS
* ZOOM_BASE
; // 'x' coordinate of right side of the dirty rectangle
2140 int b
= bot
.y
; // 'y' coordinate of bottom side of the dirty rectangle
2142 static const int OVERLAY_WIDTH
= 4 * ZOOM_BASE
; // part of selection sprites is drawn outside the selected area (in particular: terraforming)
2144 /* For halftile foundations on SLOPE_STEEP_S the sprite extents some more towards the top */
2145 MarkAllViewportsDirty(l
- OVERLAY_WIDTH
, t
- OVERLAY_WIDTH
- TILE_HEIGHT
* ZOOM_BASE
, r
+ OVERLAY_WIDTH
, b
+ OVERLAY_WIDTH
);
2147 /* haven't we reached the topmost tile yet? */
2148 if (top_x
!= x_start
) {
2154 /* the way the bottom tile changes is different when we reach the bottommost tile */
2155 if (bot_y
!= y_end
) {
2160 } while (bot_x
>= top_x
);
2161 } else { // Selecting in a 45 degrees rotated (diagonal) rectangle.
2162 /* a_size, b_size describe a rectangle with rotated coordinates */
2163 int a_size
= x_size
+ y_size
, b_size
= x_size
- y_size
;
2165 int interval_a
= a_size
< 0 ? -(int)TILE_SIZE
: (int)TILE_SIZE
;
2166 int interval_b
= b_size
< 0 ? -(int)TILE_SIZE
: (int)TILE_SIZE
;
2168 for (int a
= -interval_a
; a
!= a_size
+ interval_a
; a
+= interval_a
) {
2169 for (int b
= -interval_b
; b
!= b_size
+ interval_b
; b
+= interval_b
) {
2170 uint x
= (_thd
.pos
.x
+ (a
+ b
) / 2) / TILE_SIZE
;
2171 uint y
= (_thd
.pos
.y
+ (a
- b
) / 2) / TILE_SIZE
;
2173 if (x
< Map::MaxX() && y
< Map::MaxY()) {
2174 MarkTileDirtyByTile(TileXY(x
, y
));
2182 void SetSelectionRed(bool b
)
2184 _thd
.make_square_red
= b
;
2185 SetSelectionTilesDirty();
2189 * Test whether a sign is below the mouse
2190 * @param vp the clicked viewport
2191 * @param x X position of click
2192 * @param y Y position of click
2193 * @param sign the sign to check
2194 * @return true if the sign was hit
2196 static bool CheckClickOnViewportSign(const Viewport
*vp
, int x
, int y
, const ViewportSign
*sign
)
2198 bool small
= (vp
->zoom
>= ZOOM_LVL_OUT_4X
);
2199 int sign_half_width
= ScaleByZoom((small
? sign
->width_small
: sign
->width_normal
) / 2, vp
->zoom
);
2200 int sign_height
= ScaleByZoom(WidgetDimensions::scaled
.fullbevel
.top
+ GetCharacterHeight(small
? FS_SMALL
: FS_NORMAL
) + WidgetDimensions::scaled
.fullbevel
.bottom
, vp
->zoom
);
2202 return y
>= sign
->top
&& y
< sign
->top
+ sign_height
&&
2203 x
>= sign
->center
- sign_half_width
&& x
< sign
->center
+ sign_half_width
;
2208 * Check whether any viewport sign was clicked, and dispatch the click.
2209 * @param vp the clicked viewport
2210 * @param x X position of click
2211 * @param y Y position of click
2212 * @return true if the sign was hit
2214 static bool CheckClickOnViewportSign(const Viewport
*vp
, int x
, int y
)
2216 if (_game_mode
== GM_MENU
) return false;
2218 x
= ScaleByZoom(x
- vp
->left
, vp
->zoom
) + vp
->virtual_left
;
2219 y
= ScaleByZoom(y
- vp
->top
, vp
->zoom
) + vp
->virtual_top
;
2221 Rect search_rect
{ x
- 1, y
- 1, x
+ 1, y
+ 1 };
2222 search_rect
= ExpandRectWithViewportSignMargins(search_rect
, vp
->zoom
);
2224 bool show_stations
= HasBit(_display_opt
, DO_SHOW_STATION_NAMES
) && !IsInvisibilitySet(TO_SIGNS
);
2225 bool show_waypoints
= HasBit(_display_opt
, DO_SHOW_WAYPOINT_NAMES
) && !IsInvisibilitySet(TO_SIGNS
);
2226 bool show_towns
= HasBit(_display_opt
, DO_SHOW_TOWN_NAMES
);
2227 bool show_signs
= HasBit(_display_opt
, DO_SHOW_SIGNS
) && !IsInvisibilitySet(TO_SIGNS
);
2228 bool show_competitors
= HasBit(_display_opt
, DO_SHOW_COMPETITOR_SIGNS
);
2230 /* Topmost of each type that was hit */
2231 BaseStation
*st
= nullptr, *last_st
= nullptr;
2232 Town
*t
= nullptr, *last_t
= nullptr;
2233 Sign
*si
= nullptr, *last_si
= nullptr;
2235 /* See ViewportAddKdtreeSigns() for details on the search logic */
2236 _viewport_sign_kdtree
.FindContained(search_rect
.left
, search_rect
.top
, search_rect
.right
, search_rect
.bottom
, [&](const ViewportSignKdtreeItem
& item
) {
2237 switch (item
.type
) {
2238 case ViewportSignKdtreeItem::VKI_STATION
:
2239 if (!show_stations
) break;
2240 st
= BaseStation::Get(item
.id
.station
);
2241 if (!show_competitors
&& _local_company
!= st
->owner
&& st
->owner
!= OWNER_NONE
) break;
2242 if (CheckClickOnViewportSign(vp
, x
, y
, &st
->sign
)) last_st
= st
;
2245 case ViewportSignKdtreeItem::VKI_WAYPOINT
:
2246 if (!show_waypoints
) break;
2247 st
= BaseStation::Get(item
.id
.station
);
2248 if (!show_competitors
&& _local_company
!= st
->owner
&& st
->owner
!= OWNER_NONE
) break;
2249 if (CheckClickOnViewportSign(vp
, x
, y
, &st
->sign
)) last_st
= st
;
2252 case ViewportSignKdtreeItem::VKI_TOWN
:
2253 if (!show_towns
) break;
2254 t
= Town::Get(item
.id
.town
);
2255 if (CheckClickOnViewportSign(vp
, x
, y
, &t
->cache
.sign
)) last_t
= t
;
2258 case ViewportSignKdtreeItem::VKI_SIGN
:
2259 if (!show_signs
) break;
2260 si
= Sign::Get(item
.id
.sign
);
2261 if (!show_competitors
&& _local_company
!= si
->owner
&& si
->owner
!= OWNER_DEITY
) break;
2262 if (CheckClickOnViewportSign(vp
, x
, y
, &si
->sign
)) last_si
= si
;
2270 /* Select which hit to handle based on priority */
2271 if (last_st
!= nullptr) {
2272 if (Station::IsExpected(last_st
)) {
2273 ShowStationViewWindow(last_st
->index
);
2275 ShowWaypointWindow(Waypoint::From(last_st
));
2278 } else if (last_t
!= nullptr) {
2279 ShowTownViewWindow(last_t
->index
);
2281 } else if (last_si
!= nullptr) {
2282 HandleClickOnSign(last_si
);
2290 ViewportSignKdtreeItem
ViewportSignKdtreeItem::MakeStation(StationID id
)
2292 ViewportSignKdtreeItem item
;
2293 item
.type
= VKI_STATION
;
2294 item
.id
.station
= id
;
2296 const Station
*st
= Station::Get(id
);
2297 assert(st
->sign
.kdtree_valid
);
2298 item
.center
= st
->sign
.center
;
2299 item
.top
= st
->sign
.top
;
2301 /* Assume the sign can be a candidate for drawing, so measure its width */
2302 _viewport_sign_maxwidth
= std::max
<int>({_viewport_sign_maxwidth
, st
->sign
.width_normal
, st
->sign
.width_small
});
2307 ViewportSignKdtreeItem
ViewportSignKdtreeItem::MakeWaypoint(StationID id
)
2309 ViewportSignKdtreeItem item
;
2310 item
.type
= VKI_WAYPOINT
;
2311 item
.id
.station
= id
;
2313 const Waypoint
*st
= Waypoint::Get(id
);
2314 assert(st
->sign
.kdtree_valid
);
2315 item
.center
= st
->sign
.center
;
2316 item
.top
= st
->sign
.top
;
2318 /* Assume the sign can be a candidate for drawing, so measure its width */
2319 _viewport_sign_maxwidth
= std::max
<int>({_viewport_sign_maxwidth
, st
->sign
.width_normal
, st
->sign
.width_small
});
2324 ViewportSignKdtreeItem
ViewportSignKdtreeItem::MakeTown(TownID id
)
2326 ViewportSignKdtreeItem item
;
2327 item
.type
= VKI_TOWN
;
2330 const Town
*town
= Town::Get(id
);
2331 assert(town
->cache
.sign
.kdtree_valid
);
2332 item
.center
= town
->cache
.sign
.center
;
2333 item
.top
= town
->cache
.sign
.top
;
2335 /* Assume the sign can be a candidate for drawing, so measure its width */
2336 _viewport_sign_maxwidth
= std::max
<int>({_viewport_sign_maxwidth
, town
->cache
.sign
.width_normal
, town
->cache
.sign
.width_small
});
2341 ViewportSignKdtreeItem
ViewportSignKdtreeItem::MakeSign(SignID id
)
2343 ViewportSignKdtreeItem item
;
2344 item
.type
= VKI_SIGN
;
2347 const Sign
*sign
= Sign::Get(id
);
2348 assert(sign
->sign
.kdtree_valid
);
2349 item
.center
= sign
->sign
.center
;
2350 item
.top
= sign
->sign
.top
;
2352 /* Assume the sign can be a candidate for drawing, so measure its width */
2353 _viewport_sign_maxwidth
= std::max
<int>({_viewport_sign_maxwidth
, sign
->sign
.width_normal
, sign
->sign
.width_small
});
2358 void RebuildViewportKdtree()
2360 /* Reset biggest size sign seen */
2361 _viewport_sign_maxwidth
= 0;
2363 std::vector
<ViewportSignKdtreeItem
> items
;
2364 items
.reserve(BaseStation::GetNumItems() + Town::GetNumItems() + Sign::GetNumItems());
2366 for (const Station
*st
: Station::Iterate()) {
2367 if (st
->sign
.kdtree_valid
) items
.push_back(ViewportSignKdtreeItem::MakeStation(st
->index
));
2370 for (const Waypoint
*wp
: Waypoint::Iterate()) {
2371 if (wp
->sign
.kdtree_valid
) items
.push_back(ViewportSignKdtreeItem::MakeWaypoint(wp
->index
));
2374 for (const Town
*town
: Town::Iterate()) {
2375 if (town
->cache
.sign
.kdtree_valid
) items
.push_back(ViewportSignKdtreeItem::MakeTown(town
->index
));
2378 for (const Sign
*sign
: Sign::Iterate()) {
2379 if (sign
->sign
.kdtree_valid
) items
.push_back(ViewportSignKdtreeItem::MakeSign(sign
->index
));
2382 _viewport_sign_kdtree
.Build(items
.begin(), items
.end());
2386 static bool CheckClickOnLandscape(const Viewport
*vp
, int x
, int y
)
2388 Point pt
= TranslateXYToTileCoord(vp
, x
, y
);
2390 if (pt
.x
!= -1) return ClickTile(TileVirtXY(pt
.x
, pt
.y
));
2394 static void PlaceObject()
2399 pt
= GetTileBelowCursor();
2400 if (pt
.x
== -1) return;
2402 if ((_thd
.place_mode
& HT_DRAG_MASK
) == HT_POINT
) {
2403 pt
.x
+= TILE_SIZE
/ 2;
2404 pt
.y
+= TILE_SIZE
/ 2;
2407 _tile_fract_coords
.x
= pt
.x
& TILE_UNIT_MASK
;
2408 _tile_fract_coords
.y
= pt
.y
& TILE_UNIT_MASK
;
2410 w
= _thd
.GetCallbackWnd();
2411 if (w
!= nullptr) w
->OnPlaceObject(pt
, TileVirtXY(pt
.x
, pt
.y
));
2415 bool HandleViewportClicked(const Viewport
*vp
, int x
, int y
)
2417 const Vehicle
*v
= CheckClickOnVehicle(vp
, x
, y
);
2419 if (_thd
.place_mode
& HT_VEHICLE
) {
2420 if (v
!= nullptr && VehicleClicked(v
)) return true;
2423 /* Vehicle placement mode already handled above. */
2424 if ((_thd
.place_mode
& HT_DRAG_MASK
) != HT_NONE
) {
2429 if (CheckClickOnViewportSign(vp
, x
, y
)) return true;
2430 bool result
= CheckClickOnLandscape(vp
, x
, y
);
2433 Debug(misc
, 2, "Vehicle {} (index {}) at {}", v
->unitnumber
, v
->index
, fmt::ptr(v
));
2434 if (IsCompanyBuildableVehicleType(v
)) {
2436 if (_ctrl_pressed
&& v
->owner
== _local_company
) {
2437 StartStopVehicle(v
, true);
2439 ShowVehicleViewWindow(v
);
2447 void RebuildViewportOverlay(Window
*w
)
2449 if (w
->viewport
->overlay
!= nullptr &&
2450 w
->viewport
->overlay
->GetCompanyMask() != 0 &&
2451 w
->viewport
->overlay
->GetCargoMask() != 0) {
2452 w
->viewport
->overlay
->SetDirty();
2458 * Scrolls the viewport in a window to a given location.
2459 * @param x Desired x location of the map to scroll to (world coordinate).
2460 * @param y Desired y location of the map to scroll to (world coordinate).
2461 * @param z Desired z location of the map to scroll to (world coordinate). Use \c -1 to scroll to the height of the map at the \a x, \a y location.
2462 * @param w %Window containing the viewport.
2463 * @param instant Jump to the location instead of slowly moving to it.
2464 * @return Destination of the viewport was changed (to activate other actions when the viewport is already at the desired position).
2466 bool ScrollWindowTo(int x
, int y
, int z
, Window
*w
, bool instant
)
2468 /* The slope cannot be acquired outside of the map, so make sure we are always within the map. */
2470 if ( x
>= 0 && x
<= (int)Map::SizeX() * (int)TILE_SIZE
- 1
2471 && y
>= 0 && y
<= (int)Map::SizeY() * (int)TILE_SIZE
- 1) {
2472 z
= GetSlopePixelZ(x
, y
);
2474 z
= TileHeightOutsideMap(x
/ (int)TILE_SIZE
, y
/ (int)TILE_SIZE
);
2478 Point pt
= MapXYZToViewport(w
->viewport
, x
, y
, z
);
2479 w
->viewport
->follow_vehicle
= INVALID_VEHICLE
;
2481 if (w
->viewport
->dest_scrollpos_x
== pt
.x
&& w
->viewport
->dest_scrollpos_y
== pt
.y
) return false;
2484 w
->viewport
->scrollpos_x
= pt
.x
;
2485 w
->viewport
->scrollpos_y
= pt
.y
;
2486 RebuildViewportOverlay(w
);
2489 w
->viewport
->dest_scrollpos_x
= pt
.x
;
2490 w
->viewport
->dest_scrollpos_y
= pt
.y
;
2495 * Scrolls the viewport in a window to a given location.
2496 * @param tile Desired tile to center on.
2497 * @param w %Window containing the viewport.
2498 * @param instant Jump to the location instead of slowly moving to it.
2499 * @return Destination of the viewport was changed (to activate other actions when the viewport is already at the desired position).
2501 bool ScrollWindowToTile(TileIndex tile
, Window
*w
, bool instant
)
2503 return ScrollWindowTo(TileX(tile
) * TILE_SIZE
, TileY(tile
) * TILE_SIZE
, -1, w
, instant
);
2507 * Scrolls the viewport of the main window to a given location.
2508 * @param tile Desired tile to center on.
2509 * @param instant Jump to the location instead of slowly moving to it.
2510 * @return Destination of the viewport was changed (to activate other actions when the viewport is already at the desired position).
2512 bool ScrollMainWindowToTile(TileIndex tile
, bool instant
)
2514 return ScrollMainWindowTo(TileX(tile
) * TILE_SIZE
+ TILE_SIZE
/ 2, TileY(tile
) * TILE_SIZE
+ TILE_SIZE
/ 2, -1, instant
);
2518 * Set a tile to display a red error square.
2519 * @param tile Tile that should show the red error square.
2521 void SetRedErrorSquare(TileIndex tile
)
2529 if (tile
!= INVALID_TILE
) MarkTileDirtyByTile(tile
);
2530 if (old
!= INVALID_TILE
) MarkTileDirtyByTile(old
);
2535 * Highlight \a w by \a h tiles at the cursor.
2536 * @param w Width of the highlighted tiles rectangle.
2537 * @param h Height of the highlighted tiles rectangle.
2539 void SetTileSelectSize(int w
, int h
)
2541 _thd
.new_size
.x
= w
* TILE_SIZE
;
2542 _thd
.new_size
.y
= h
* TILE_SIZE
;
2543 _thd
.new_outersize
.x
= 0;
2544 _thd
.new_outersize
.y
= 0;
2547 void SetTileSelectBigSize(int ox
, int oy
, int sx
, int sy
)
2549 _thd
.offs
.x
= ox
* TILE_SIZE
;
2550 _thd
.offs
.y
= oy
* TILE_SIZE
;
2551 _thd
.new_outersize
.x
= sx
* TILE_SIZE
;
2552 _thd
.new_outersize
.y
= sy
* TILE_SIZE
;
2555 /** returns the best autorail highlight type from map coordinates */
2556 static HighLightStyle
GetAutorailHT(int x
, int y
)
2558 return HT_RAIL
| _autorail_piece
[x
& TILE_UNIT_MASK
][y
& TILE_UNIT_MASK
];
2562 * Reset tile highlighting.
2564 void TileHighlightData::Reset()
2568 this->new_pos
.x
= 0;
2569 this->new_pos
.y
= 0;
2573 * Is the user dragging a 'diagonal rectangle'?
2574 * @return User is dragging a rotated rectangle.
2576 bool TileHighlightData::IsDraggingDiagonal()
2578 return (this->place_mode
& HT_DIAGONAL
) != 0 && _ctrl_pressed
&& _left_button_down
;
2582 * Get the window that started the current highlighting.
2583 * @return The window that requested the current tile highlighting, or \c nullptr if not available.
2585 Window
*TileHighlightData::GetCallbackWnd()
2587 return FindWindowById(this->window_class
, this->window_number
);
2593 * Updates tile highlighting for all cases.
2594 * Uses _thd.selstart and _thd.selend and _thd.place_mode (set elsewhere) to determine _thd.pos and _thd.size
2595 * Also drawstyle is determined. Uses _thd.new.* as a buffer and calls SetSelectionTilesDirty() twice,
2596 * Once for the old and once for the new selection.
2597 * _thd is TileHighlightData, found in viewport.h
2599 void UpdateTileSelection()
2604 if (_thd
.freeze
) return;
2606 HighLightStyle new_drawstyle
= HT_NONE
;
2607 bool new_diagonal
= false;
2609 if ((_thd
.place_mode
& HT_DRAG_MASK
) == HT_SPECIAL
) {
2613 int x2
= _thd
.selstart
.x
& ~TILE_UNIT_MASK
;
2614 int y2
= _thd
.selstart
.y
& ~TILE_UNIT_MASK
;
2615 x1
&= ~TILE_UNIT_MASK
;
2616 y1
&= ~TILE_UNIT_MASK
;
2618 if (_thd
.IsDraggingDiagonal()) {
2619 new_diagonal
= true;
2621 if (x1
>= x2
) Swap(x1
, x2
);
2622 if (y1
>= y2
) Swap(y1
, y2
);
2624 _thd
.new_pos
.x
= x1
;
2625 _thd
.new_pos
.y
= y1
;
2626 _thd
.new_size
.x
= x2
- x1
;
2627 _thd
.new_size
.y
= y2
- y1
;
2628 if (!new_diagonal
) {
2629 _thd
.new_size
.x
+= TILE_SIZE
;
2630 _thd
.new_size
.y
+= TILE_SIZE
;
2632 new_drawstyle
= _thd
.next_drawstyle
;
2634 } else if ((_thd
.place_mode
& HT_DRAG_MASK
) != HT_NONE
) {
2635 Point pt
= GetTileBelowCursor();
2639 switch (_thd
.place_mode
& HT_DRAG_MASK
) {
2641 new_drawstyle
= HT_RECT
;
2644 new_drawstyle
= HT_POINT
;
2645 x1
+= TILE_SIZE
/ 2;
2646 y1
+= TILE_SIZE
/ 2;
2649 /* Draw one highlighted tile in any direction */
2650 new_drawstyle
= GetAutorailHT(pt
.x
, pt
.y
);
2653 switch (_thd
.place_mode
& HT_DIR_MASK
) {
2654 case HT_DIR_X
: new_drawstyle
= HT_LINE
| HT_DIR_X
; break;
2655 case HT_DIR_Y
: new_drawstyle
= HT_LINE
| HT_DIR_Y
; break;
2659 new_drawstyle
= (pt
.x
& TILE_UNIT_MASK
) + (pt
.y
& TILE_UNIT_MASK
) <= TILE_SIZE
? HT_LINE
| HT_DIR_HU
: HT_LINE
| HT_DIR_HL
;
2664 new_drawstyle
= (pt
.x
& TILE_UNIT_MASK
) > (pt
.y
& TILE_UNIT_MASK
) ? HT_LINE
| HT_DIR_VL
: HT_LINE
| HT_DIR_VR
;
2667 default: NOT_REACHED();
2669 _thd
.selstart
.x
= x1
& ~TILE_UNIT_MASK
;
2670 _thd
.selstart
.y
= y1
& ~TILE_UNIT_MASK
;
2675 _thd
.new_pos
.x
= x1
& ~TILE_UNIT_MASK
;
2676 _thd
.new_pos
.y
= y1
& ~TILE_UNIT_MASK
;
2680 /* redraw selection */
2681 if (_thd
.drawstyle
!= new_drawstyle
||
2682 _thd
.pos
.x
!= _thd
.new_pos
.x
|| _thd
.pos
.y
!= _thd
.new_pos
.y
||
2683 _thd
.size
.x
!= _thd
.new_size
.x
|| _thd
.size
.y
!= _thd
.new_size
.y
||
2684 _thd
.outersize
.x
!= _thd
.new_outersize
.x
||
2685 _thd
.outersize
.y
!= _thd
.new_outersize
.y
||
2686 _thd
.diagonal
!= new_diagonal
) {
2687 /* Clear the old tile selection? */
2688 if ((_thd
.drawstyle
& HT_DRAG_MASK
) != HT_NONE
) SetSelectionTilesDirty();
2690 _thd
.drawstyle
= new_drawstyle
;
2691 _thd
.pos
= _thd
.new_pos
;
2692 _thd
.size
= _thd
.new_size
;
2693 _thd
.outersize
= _thd
.new_outersize
;
2694 _thd
.diagonal
= new_diagonal
;
2697 /* Draw the new tile selection? */
2698 if ((new_drawstyle
& HT_DRAG_MASK
) != HT_NONE
) SetSelectionTilesDirty();
2703 * Displays the measurement tooltips when selecting multiple tiles
2704 * @param str String to be displayed
2705 * @param paramcount number of params to deal with
2707 static inline void ShowMeasurementTooltips(StringID str
, uint paramcount
)
2709 if (!_settings_client
.gui
.measure_tooltip
) return;
2710 GuiShowTooltips(_thd
.GetCallbackWnd(), str
, TCC_EXIT_VIEWPORT
, paramcount
);
2713 static void HideMeasurementTooltips()
2715 CloseWindowById(WC_TOOLTIPS
, 0);
2718 /** highlighting tiles while only going over them with the mouse */
2719 void VpStartPlaceSizing(TileIndex tile
, ViewportPlaceMethod method
, ViewportDragDropSelectionProcess process
)
2721 _thd
.select_method
= method
;
2722 _thd
.select_proc
= process
;
2723 _thd
.selend
.x
= TileX(tile
) * TILE_SIZE
;
2724 _thd
.selstart
.x
= TileX(tile
) * TILE_SIZE
;
2725 _thd
.selend
.y
= TileY(tile
) * TILE_SIZE
;
2726 _thd
.selstart
.y
= TileY(tile
) * TILE_SIZE
;
2728 /* Needed so several things (road, autoroad, bridges, ...) are placed correctly.
2729 * In effect, placement starts from the centre of a tile
2731 if (method
== VPM_X_OR_Y
|| method
== VPM_FIX_X
|| method
== VPM_FIX_Y
) {
2732 _thd
.selend
.x
+= TILE_SIZE
/ 2;
2733 _thd
.selend
.y
+= TILE_SIZE
/ 2;
2734 _thd
.selstart
.x
+= TILE_SIZE
/ 2;
2735 _thd
.selstart
.y
+= TILE_SIZE
/ 2;
2738 HighLightStyle others
= _thd
.place_mode
& ~(HT_DRAG_MASK
| HT_DIR_MASK
);
2739 if ((_thd
.place_mode
& HT_DRAG_MASK
) == HT_RECT
) {
2740 _thd
.place_mode
= HT_SPECIAL
| others
;
2741 _thd
.next_drawstyle
= HT_RECT
| others
;
2742 } else if (_thd
.place_mode
& (HT_RAIL
| HT_LINE
)) {
2743 _thd
.place_mode
= HT_SPECIAL
| others
;
2744 _thd
.next_drawstyle
= _thd
.drawstyle
| others
;
2746 _thd
.place_mode
= HT_SPECIAL
| others
;
2747 _thd
.next_drawstyle
= HT_POINT
| others
;
2749 _special_mouse_mode
= WSM_SIZING
;
2752 /** Drag over the map while holding the left mouse down. */
2753 void VpStartDragging(ViewportDragDropSelectionProcess process
)
2755 _thd
.select_method
= VPM_X_AND_Y
;
2756 _thd
.select_proc
= process
;
2757 _thd
.selstart
.x
= 0;
2758 _thd
.selstart
.y
= 0;
2759 _thd
.next_drawstyle
= HT_RECT
;
2761 _special_mouse_mode
= WSM_DRAGGING
;
2764 void VpSetPlaceSizingLimit(int limit
)
2766 _thd
.sizelimit
= limit
;
2770 * Highlights all tiles between a set of two tiles. Used in dock and tunnel placement
2771 * @param from TileIndex of the first tile to highlight
2772 * @param to TileIndex of the last tile to highlight
2774 void VpSetPresizeRange(TileIndex from
, TileIndex to
)
2776 uint64_t distance
= DistanceManhattan(from
, to
) + 1;
2778 _thd
.selend
.x
= TileX(to
) * TILE_SIZE
;
2779 _thd
.selend
.y
= TileY(to
) * TILE_SIZE
;
2780 _thd
.selstart
.x
= TileX(from
) * TILE_SIZE
;
2781 _thd
.selstart
.y
= TileY(from
) * TILE_SIZE
;
2782 _thd
.next_drawstyle
= HT_RECT
;
2784 /* show measurement only if there is any length to speak of */
2786 SetDParam(0, distance
);
2787 ShowMeasurementTooltips(STR_MEASURE_LENGTH
, 1);
2789 HideMeasurementTooltips();
2793 static void VpStartPreSizing()
2796 _special_mouse_mode
= WSM_PRESIZE
;
2800 * returns information about the 2x1 piece to be build.
2801 * The lower bits (0-3) are the track type.
2803 static HighLightStyle
Check2x1AutoRail(int mode
)
2805 int fxpy
= _tile_fract_coords
.x
+ _tile_fract_coords
.y
;
2806 int sxpy
= (_thd
.selend
.x
& TILE_UNIT_MASK
) + (_thd
.selend
.y
& TILE_UNIT_MASK
);
2807 int fxmy
= _tile_fract_coords
.x
- _tile_fract_coords
.y
;
2808 int sxmy
= (_thd
.selend
.x
& TILE_UNIT_MASK
) - (_thd
.selend
.y
& TILE_UNIT_MASK
);
2811 default: NOT_REACHED();
2812 case 0: // end piece is lower right
2813 if (fxpy
>= 20 && sxpy
<= 12) return HT_DIR_HL
;
2814 if (fxmy
< -3 && sxmy
> 3) return HT_DIR_VR
;
2818 if (fxmy
> 3 && sxmy
< -3) return HT_DIR_VL
;
2819 if (fxpy
<= 12 && sxpy
>= 20) return HT_DIR_HU
;
2823 if (fxmy
> 3 && sxmy
< -3) return HT_DIR_VL
;
2824 if (fxpy
>= 20 && sxpy
<= 12) return HT_DIR_HL
;
2828 if (fxmy
< -3 && sxmy
> 3) return HT_DIR_VR
;
2829 if (fxpy
<= 12 && sxpy
>= 20) return HT_DIR_HU
;
2835 * Check if the direction of start and end tile should be swapped based on
2836 * the dragging-style. Default directions are:
2837 * in the case of a line (HT_RAIL, HT_LINE): DIR_NE, DIR_NW, DIR_N, DIR_E
2838 * in the case of a rect (HT_RECT, HT_POINT): DIR_S, DIR_E
2839 * For example dragging a rectangle area from south to north should be swapped to
2840 * north-south (DIR_S) to obtain the same results with less code. This is what
2841 * the return value signifies.
2842 * @param style HighLightStyle dragging style
2843 * @param start_tile start tile of drag
2844 * @param end_tile end tile of drag
2845 * @return boolean value which when true means start/end should be swapped
2847 static bool SwapDirection(HighLightStyle style
, TileIndex start_tile
, TileIndex end_tile
)
2849 uint start_x
= TileX(start_tile
);
2850 uint start_y
= TileY(start_tile
);
2851 uint end_x
= TileX(end_tile
);
2852 uint end_y
= TileY(end_tile
);
2854 switch (style
& HT_DRAG_MASK
) {
2856 case HT_LINE
: return (end_x
> start_x
|| (end_x
== start_x
&& end_y
> start_y
));
2859 case HT_POINT
: return (end_x
!= start_x
&& end_y
< start_y
);
2860 default: NOT_REACHED();
2867 * Calculates height difference between one tile and another.
2868 * Multiplies the result to suit the standard given by #TILE_HEIGHT_STEP.
2870 * To correctly get the height difference we need the direction we are dragging
2871 * in, as well as with what kind of tool we are dragging. For example a horizontal
2872 * autorail tool that starts in bottom and ends at the top of a tile will need the
2873 * maximum of SW, S and SE, N corners respectively. This is handled by the lookup table below
2874 * See #_tileoffs_by_dir in map.cpp for the direction enums if you can't figure out the values yourself.
2875 * @param style Highlighting style of the drag. This includes direction and style (autorail, rect, etc.)
2876 * @param distance Number of tiles dragged, important for horizontal/vertical drags, ignored for others.
2877 * @param start_tile Start tile of the drag operation.
2878 * @param end_tile End tile of the drag operation.
2879 * @return Height difference between two tiles. The tile measurement tool utilizes this value in its tooltip.
2881 static int CalcHeightdiff(HighLightStyle style
, uint distance
, TileIndex start_tile
, TileIndex end_tile
)
2883 bool swap
= SwapDirection(style
, start_tile
, end_tile
);
2884 uint h0
, h1
; // Start height and end height.
2886 if (start_tile
== end_tile
) return 0;
2887 if (swap
) Swap(start_tile
, end_tile
);
2889 switch (style
& HT_DRAG_MASK
) {
2891 /* In the case of an area we can determine whether we were dragging south or
2892 * east by checking the X-coordinates of the tiles */
2893 if (TileX(end_tile
) > TileX(start_tile
)) {
2894 /* Dragging south does not need to change the start tile. */
2895 end_tile
= TileAddByDir(end_tile
, DIR_S
);
2897 /* Dragging east. */
2898 start_tile
= TileAddByDir(start_tile
, DIR_SW
);
2899 end_tile
= TileAddByDir(end_tile
, DIR_SE
);
2904 h0
= TileHeight(start_tile
);
2905 h1
= TileHeight(end_tile
);
2907 default: { // All other types, this is mostly only line/autorail
2908 static const HighLightStyle flip_style_direction
[] = {
2909 HT_DIR_X
, HT_DIR_Y
, HT_DIR_HL
, HT_DIR_HU
, HT_DIR_VR
, HT_DIR_VL
2911 static const std::pair
<TileIndexDiffC
, TileIndexDiffC
> start_heightdiff_line_by_dir
[] = {
2912 { {1, 0}, {1, 1} }, // HT_DIR_X
2913 { {0, 1}, {1, 1} }, // HT_DIR_Y
2914 { {1, 0}, {0, 0} }, // HT_DIR_HU
2915 { {1, 0}, {1, 1} }, // HT_DIR_HL
2916 { {1, 0}, {1, 1} }, // HT_DIR_VL
2917 { {0, 1}, {1, 1} }, // HT_DIR_VR
2919 static const std::pair
<TileIndexDiffC
, TileIndexDiffC
> end_heightdiff_line_by_dir
[] = {
2920 { {0, 1}, {0, 0} }, // HT_DIR_X
2921 { {1, 0}, {0, 0} }, // HT_DIR_Y
2922 { {0, 1}, {0, 0} }, // HT_DIR_HU
2923 { {1, 1}, {0, 1} }, // HT_DIR_HL
2924 { {1, 0}, {0, 0} }, // HT_DIR_VL
2925 { {0, 0}, {0, 1} }, // HT_DIR_VR
2927 static_assert(std::size(start_heightdiff_line_by_dir
) == HT_DIR_END
);
2928 static_assert(std::size(end_heightdiff_line_by_dir
) == HT_DIR_END
);
2930 distance
%= 2; // we're only interested if the distance is even or uneven
2931 style
&= HT_DIR_MASK
;
2932 assert(style
< HT_DIR_END
);
2934 /* To handle autorail, we do some magic to be able to use a lookup table.
2935 * Firstly if we drag the other way around, we switch start&end, and if needed
2936 * also flip the drag-position. Eg if it was on the left, and the distance is even
2937 * that means the end, which is now the start is on the right */
2938 if (swap
&& distance
== 0) style
= flip_style_direction
[style
];
2940 /* Lambda to help calculating the height at one side of the line. */
2941 auto get_height
= [](auto &tile
, auto &heightdiffs
) {
2943 TileHeight(TileAdd(tile
, ToTileIndexDiff(heightdiffs
.first
))),
2944 TileHeight(TileAdd(tile
, ToTileIndexDiff(heightdiffs
.second
))));
2947 /* Use lookup table for start-tile based on HighLightStyle direction */
2948 h0
= get_height(start_tile
, start_heightdiff_line_by_dir
[style
]);
2950 /* Use lookup table for end-tile based on HighLightStyle direction
2951 * flip around side (lower/upper, left/right) based on distance */
2952 if (distance
== 0) style
= flip_style_direction
[style
];
2953 h1
= get_height(end_tile
, end_heightdiff_line_by_dir
[style
]);
2958 if (swap
) Swap(h0
, h1
);
2959 return (int)(h1
- h0
) * TILE_HEIGHT_STEP
;
2962 static const StringID measure_strings_length
[] = {STR_NULL
, STR_MEASURE_LENGTH
, STR_MEASURE_LENGTH_HEIGHTDIFF
};
2965 * Check for underflowing the map.
2966 * @param test the variable to test for underflowing
2967 * @param other the other variable to update to keep the line
2968 * @param mult the constant to multiply the difference by for \c other
2970 static void CheckUnderflow(int &test
, int &other
, int mult
)
2972 if (test
>= 0) return;
2974 other
+= mult
* test
;
2979 * Check for overflowing the map.
2980 * @param test the variable to test for overflowing
2981 * @param other the other variable to update to keep the line
2982 * @param max the maximum value for the \c test variable
2983 * @param mult the constant to multiply the difference by for \c other
2985 static void CheckOverflow(int &test
, int &other
, int max
, int mult
)
2987 if (test
<= max
) return;
2989 other
+= mult
* (test
- max
);
2993 /** while dragging */
2994 static void CalcRaildirsDrawstyle(int x
, int y
, int method
)
2998 int dx
= _thd
.selstart
.x
- (_thd
.selend
.x
& ~TILE_UNIT_MASK
);
2999 int dy
= _thd
.selstart
.y
- (_thd
.selend
.y
& ~TILE_UNIT_MASK
);
3000 uint w
= abs(dx
) + TILE_SIZE
;
3001 uint h
= abs(dy
) + TILE_SIZE
;
3003 if (method
& ~(VPM_RAILDIRS
| VPM_SIGNALDIRS
)) {
3004 /* We 'force' a selection direction; first four rail buttons. */
3005 method
&= ~(VPM_RAILDIRS
| VPM_SIGNALDIRS
);
3006 int raw_dx
= _thd
.selstart
.x
- _thd
.selend
.x
;
3007 int raw_dy
= _thd
.selstart
.y
- _thd
.selend
.y
;
3010 b
= HT_LINE
| HT_DIR_Y
;
3011 x
= _thd
.selstart
.x
;
3015 b
= HT_LINE
| HT_DIR_X
;
3016 y
= _thd
.selstart
.y
;
3019 case VPM_FIX_HORIZONTAL
:
3021 /* We are on a straight horizontal line. Determine the 'rail'
3022 * to build based the sub tile location. */
3023 b
= (x
& TILE_UNIT_MASK
) + (y
& TILE_UNIT_MASK
) >= TILE_SIZE
? HT_LINE
| HT_DIR_HL
: HT_LINE
| HT_DIR_HU
;
3025 /* We are not on a straight line. Determine the rail to build
3026 * based on whether we are above or below it. */
3027 b
= dx
+ dy
>= (int)TILE_SIZE
? HT_LINE
| HT_DIR_HU
: HT_LINE
| HT_DIR_HL
;
3029 /* Calculate where a horizontal line through the start point and
3030 * a vertical line from the selected end point intersect and
3031 * use that point as the end point. */
3032 int offset
= (raw_dx
- raw_dy
) / 2;
3033 x
= _thd
.selstart
.x
- (offset
& ~TILE_UNIT_MASK
);
3034 y
= _thd
.selstart
.y
+ (offset
& ~TILE_UNIT_MASK
);
3036 /* 'Build' the last half rail tile if needed */
3037 if ((offset
& TILE_UNIT_MASK
) > (TILE_SIZE
/ 2)) {
3038 if (dx
+ dy
>= (int)TILE_SIZE
) {
3039 x
+= (dx
+ dy
< 0) ? (int)TILE_SIZE
: -(int)TILE_SIZE
;
3041 y
+= (dx
+ dy
< 0) ? (int)TILE_SIZE
: -(int)TILE_SIZE
;
3045 /* Make sure we do not overflow the map! */
3046 CheckUnderflow(x
, y
, 1);
3047 CheckUnderflow(y
, x
, 1);
3048 CheckOverflow(x
, y
, (Map::MaxX() - 1) * TILE_SIZE
, 1);
3049 CheckOverflow(y
, x
, (Map::MaxY() - 1) * TILE_SIZE
, 1);
3050 assert(x
>= 0 && y
>= 0 && x
<= (int)(Map::MaxX() * TILE_SIZE
) && y
<= (int)(Map::MaxY() * TILE_SIZE
));
3054 case VPM_FIX_VERTICAL
:
3056 /* We are on a straight vertical line. Determine the 'rail'
3057 * to build based the sub tile location. */
3058 b
= (x
& TILE_UNIT_MASK
) > (y
& TILE_UNIT_MASK
) ? HT_LINE
| HT_DIR_VL
: HT_LINE
| HT_DIR_VR
;
3060 /* We are not on a straight line. Determine the rail to build
3061 * based on whether we are left or right from it. */
3062 b
= dx
< dy
? HT_LINE
| HT_DIR_VL
: HT_LINE
| HT_DIR_VR
;
3064 /* Calculate where a vertical line through the start point and
3065 * a horizontal line from the selected end point intersect and
3066 * use that point as the end point. */
3067 int offset
= (raw_dx
+ raw_dy
+ (int)TILE_SIZE
) / 2;
3068 x
= _thd
.selstart
.x
- (offset
& ~TILE_UNIT_MASK
);
3069 y
= _thd
.selstart
.y
- (offset
& ~TILE_UNIT_MASK
);
3071 /* 'Build' the last half rail tile if needed */
3072 if ((offset
& TILE_UNIT_MASK
) > (TILE_SIZE
/ 2)) {
3074 y
+= (dx
> dy
) ? (int)TILE_SIZE
: -(int)TILE_SIZE
;
3076 x
+= (dx
< dy
) ? (int)TILE_SIZE
: -(int)TILE_SIZE
;
3080 /* Make sure we do not overflow the map! */
3081 CheckUnderflow(x
, y
, -1);
3082 CheckUnderflow(y
, x
, -1);
3083 CheckOverflow(x
, y
, (Map::MaxX() - 1) * TILE_SIZE
, -1);
3084 CheckOverflow(y
, x
, (Map::MaxY() - 1) * TILE_SIZE
, -1);
3085 assert(x
>= 0 && y
>= 0 && x
<= (int)(Map::MaxX() * TILE_SIZE
) && y
<= (int)(Map::MaxY() * TILE_SIZE
));
3092 } else if (TileVirtXY(_thd
.selstart
.x
, _thd
.selstart
.y
) == TileVirtXY(x
, y
)) { // check if we're only within one tile
3093 if (method
& VPM_RAILDIRS
) {
3094 b
= GetAutorailHT(x
, y
);
3095 } else { // rect for autosignals on one tile
3098 } else if (h
== TILE_SIZE
) { // Is this in X direction?
3099 if (dx
== (int)TILE_SIZE
) { // 2x1 special handling
3100 b
= (Check2x1AutoRail(3)) | HT_LINE
;
3101 } else if (dx
== -(int)TILE_SIZE
) {
3102 b
= (Check2x1AutoRail(2)) | HT_LINE
;
3104 b
= HT_LINE
| HT_DIR_X
;
3106 y
= _thd
.selstart
.y
;
3107 } else if (w
== TILE_SIZE
) { // Or Y direction?
3108 if (dy
== (int)TILE_SIZE
) { // 2x1 special handling
3109 b
= (Check2x1AutoRail(1)) | HT_LINE
;
3110 } else if (dy
== -(int)TILE_SIZE
) { // 2x1 other direction
3111 b
= (Check2x1AutoRail(0)) | HT_LINE
;
3113 b
= HT_LINE
| HT_DIR_Y
;
3115 x
= _thd
.selstart
.x
;
3116 } else if (w
> h
* 2) { // still count as x dir?
3117 b
= HT_LINE
| HT_DIR_X
;
3118 y
= _thd
.selstart
.y
;
3119 } else if (h
> w
* 2) { // still count as y dir?
3120 b
= HT_LINE
| HT_DIR_Y
;
3121 x
= _thd
.selstart
.x
;
3122 } else { // complicated direction
3124 _thd
.selend
.x
= _thd
.selend
.x
& ~TILE_UNIT_MASK
;
3125 _thd
.selend
.y
= _thd
.selend
.y
& ~TILE_UNIT_MASK
;
3128 if (x
> _thd
.selstart
.x
) {
3129 if (y
> _thd
.selstart
.y
) {
3132 b
= (x
& TILE_UNIT_MASK
) > (y
& TILE_UNIT_MASK
) ? HT_LINE
| HT_DIR_VL
: HT_LINE
| HT_DIR_VR
;
3133 } else if (d
>= 0) {
3134 x
= _thd
.selstart
.x
+ h
;
3135 b
= HT_LINE
| HT_DIR_VL
;
3137 y
= _thd
.selstart
.y
+ w
;
3138 b
= HT_LINE
| HT_DIR_VR
;
3143 b
= (x
& TILE_UNIT_MASK
) + (y
& TILE_UNIT_MASK
) >= TILE_SIZE
? HT_LINE
| HT_DIR_HL
: HT_LINE
| HT_DIR_HU
;
3144 } else if (d
>= 0) {
3145 x
= _thd
.selstart
.x
+ h
;
3146 b
= HT_LINE
| HT_DIR_HL
;
3148 y
= _thd
.selstart
.y
- w
;
3149 b
= HT_LINE
| HT_DIR_HU
;
3153 if (y
> _thd
.selstart
.y
) {
3156 b
= (x
& TILE_UNIT_MASK
) + (y
& TILE_UNIT_MASK
) >= TILE_SIZE
? HT_LINE
| HT_DIR_HL
: HT_LINE
| HT_DIR_HU
;
3157 } else if (d
>= 0) {
3158 x
= _thd
.selstart
.x
- h
;
3159 b
= HT_LINE
| HT_DIR_HU
;
3161 y
= _thd
.selstart
.y
+ w
;
3162 b
= HT_LINE
| HT_DIR_HL
;
3167 b
= (x
& TILE_UNIT_MASK
) > (y
& TILE_UNIT_MASK
) ? HT_LINE
| HT_DIR_VL
: HT_LINE
| HT_DIR_VR
;
3168 } else if (d
>= 0) {
3169 x
= _thd
.selstart
.x
- h
;
3170 b
= HT_LINE
| HT_DIR_VR
;
3172 y
= _thd
.selstart
.y
- w
;
3173 b
= HT_LINE
| HT_DIR_VL
;
3179 if (_settings_client
.gui
.measure_tooltip
) {
3180 TileIndex t0
= TileVirtXY(_thd
.selstart
.x
, _thd
.selstart
.y
);
3181 TileIndex t1
= TileVirtXY(x
, y
);
3182 uint distance
= DistanceManhattan(t0
, t1
) + 1;
3185 if (distance
!= 1) {
3186 int heightdiff
= CalcHeightdiff(b
, distance
, t0
, t1
);
3187 /* If we are showing a tooltip for horizontal or vertical drags,
3188 * 2 tiles have a length of 1. To bias towards the ceiling we add
3189 * one before division. It feels more natural to count 3 lengths as 2 */
3190 if ((b
& HT_DIR_MASK
) != HT_DIR_X
&& (b
& HT_DIR_MASK
) != HT_DIR_Y
) {
3191 distance
= CeilDiv(distance
, 2);
3194 SetDParam(index
++, distance
);
3195 if (heightdiff
!= 0) SetDParam(index
++, heightdiff
);
3198 ShowMeasurementTooltips(measure_strings_length
[index
], index
);
3203 _thd
.next_drawstyle
= b
;
3207 * Selects tiles while dragging
3208 * @param x X coordinate of end of selection
3209 * @param y Y coordinate of end of selection
3210 * @param method modifies the way tiles are selected. Possible
3211 * methods are VPM_* in viewport.h
3213 void VpSelectTilesWithMethod(int x
, int y
, ViewportPlaceMethod method
)
3216 HighLightStyle style
;
3223 /* Special handling of drag in any (8-way) direction */
3224 if (method
& (VPM_RAILDIRS
| VPM_SIGNALDIRS
)) {
3227 CalcRaildirsDrawstyle(x
, y
, method
);
3231 /* Needed so level-land is placed correctly */
3232 if ((_thd
.next_drawstyle
& HT_DRAG_MASK
) == HT_POINT
) {
3237 sx
= _thd
.selstart
.x
;
3238 sy
= _thd
.selstart
.y
;
3243 case VPM_X_OR_Y
: // drag in X or Y direction
3244 if (abs(sy
- y
) < abs(sx
- x
)) {
3251 goto calc_heightdiff_single_direction
;
3253 case VPM_X_LIMITED
: // Drag in X direction (limited size).
3254 limit
= (_thd
.sizelimit
- 1) * TILE_SIZE
;
3257 case VPM_FIX_X
: // drag in Y direction
3260 goto calc_heightdiff_single_direction
;
3262 case VPM_Y_LIMITED
: // Drag in Y direction (limited size).
3263 limit
= (_thd
.sizelimit
- 1) * TILE_SIZE
;
3266 case VPM_FIX_Y
: // drag in X direction
3270 calc_heightdiff_single_direction
:;
3272 x
= sx
+ Clamp(x
- sx
, -limit
, limit
);
3273 y
= sy
+ Clamp(y
- sy
, -limit
, limit
);
3275 if (_settings_client
.gui
.measure_tooltip
) {
3276 TileIndex t0
= TileVirtXY(sx
, sy
);
3277 TileIndex t1
= TileVirtXY(x
, y
);
3278 uint distance
= DistanceManhattan(t0
, t1
) + 1;
3281 if (distance
!= 1) {
3282 /* With current code passing a HT_LINE style to calculate the height
3283 * difference is enough. However if/when a point-tool is created
3284 * with this method, function should be called with new_style (below)
3285 * instead of HT_LINE | style case HT_POINT is handled specially
3286 * new_style := (_thd.next_drawstyle & HT_RECT) ? HT_LINE | style : _thd.next_drawstyle; */
3287 int heightdiff
= CalcHeightdiff(HT_LINE
| style
, 0, t0
, t1
);
3289 SetDParam(index
++, distance
);
3290 if (heightdiff
!= 0) SetDParam(index
++, heightdiff
);
3293 ShowMeasurementTooltips(measure_strings_length
[index
], index
);
3297 case VPM_X_AND_Y_LIMITED
: // Drag an X by Y constrained rect area.
3298 limit
= (_thd
.sizelimit
- 1) * TILE_SIZE
;
3299 x
= sx
+ Clamp(x
- sx
, -limit
, limit
);
3300 y
= sy
+ Clamp(y
- sy
, -limit
, limit
);
3303 case VPM_X_AND_Y
: // drag an X by Y area
3304 if (_settings_client
.gui
.measure_tooltip
) {
3305 static const StringID measure_strings_area
[] = {
3306 STR_NULL
, STR_NULL
, STR_MEASURE_AREA
, STR_MEASURE_AREA_HEIGHTDIFF
3309 TileIndex t0
= TileVirtXY(sx
, sy
);
3310 TileIndex t1
= TileVirtXY(x
, y
);
3311 uint dx
= Delta(TileX(t0
), TileX(t1
)) + 1;
3312 uint dy
= Delta(TileY(t0
), TileY(t1
)) + 1;
3315 /* If dragging an area (eg dynamite tool) and it is actually a single
3316 * row/column, change the type to 'line' to get proper calculation for height */
3317 style
= (HighLightStyle
)_thd
.next_drawstyle
;
3318 if (_thd
.IsDraggingDiagonal()) {
3319 /* Determine the "area" of the diagonal dragged selection.
3320 * We assume the area is the number of tiles along the X
3321 * edge and the number of tiles along the Y edge. However,
3322 * multiplying these two numbers does not give the exact
3323 * number of tiles; basically we are counting the black
3324 * squares on a chess board and ignore the white ones to
3325 * make the tile counts at the edges match up. There is no
3326 * other way to make a proper count though.
3328 * First convert to the rotated coordinate system. */
3329 int dist_x
= TileX(t0
) - TileX(t1
);
3330 int dist_y
= TileY(t0
) - TileY(t1
);
3331 int a_max
= dist_x
+ dist_y
;
3332 int b_max
= dist_y
- dist_x
;
3334 /* Now determine the size along the edge, but due to the
3335 * chess board principle this counts double. */
3336 a_max
= abs(a_max
+ (a_max
> 0 ? 2 : -2)) / 2;
3337 b_max
= abs(b_max
+ (b_max
> 0 ? 2 : -2)) / 2;
3339 /* We get a 1x1 on normal 2x1 rectangles, due to it being
3340 * a seen as two sides. As the result for actual building
3341 * will be the same as non-diagonal dragging revert to that
3342 * behaviour to give it a more normally looking size. */
3343 if (a_max
!= 1 || b_max
!= 1) {
3347 } else if (style
& HT_RECT
) {
3349 style
= HT_LINE
| HT_DIR_Y
;
3350 } else if (dy
== 1) {
3351 style
= HT_LINE
| HT_DIR_X
;
3355 if (dx
!= 1 || dy
!= 1) {
3356 int heightdiff
= CalcHeightdiff(style
, 0, t0
, t1
);
3358 SetDParam(index
++, dx
- (style
& HT_POINT
? 1 : 0));
3359 SetDParam(index
++, dy
- (style
& HT_POINT
? 1 : 0));
3360 if (heightdiff
!= 0) SetDParam(index
++, heightdiff
);
3363 ShowMeasurementTooltips(measure_strings_area
[index
], index
);
3367 default: NOT_REACHED();
3375 * Handle the mouse while dragging for placement/resizing.
3376 * @return State of handling the event.
3378 EventState
VpHandlePlaceSizingDrag()
3380 if (_special_mouse_mode
!= WSM_SIZING
&& _special_mouse_mode
!= WSM_DRAGGING
) return ES_NOT_HANDLED
;
3382 /* stop drag mode if the window has been closed */
3383 Window
*w
= _thd
.GetCallbackWnd();
3385 ResetObjectToPlace();
3389 /* while dragging execute the drag procedure of the corresponding window (mostly VpSelectTilesWithMethod() ) */
3390 if (_left_button_down
) {
3391 if (_special_mouse_mode
== WSM_DRAGGING
) {
3392 /* Only register a drag event when the mouse moved. */
3393 if (_thd
.new_pos
.x
== _thd
.selstart
.x
&& _thd
.new_pos
.y
== _thd
.selstart
.y
) return ES_HANDLED
;
3394 _thd
.selstart
.x
= _thd
.new_pos
.x
;
3395 _thd
.selstart
.y
= _thd
.new_pos
.y
;
3398 w
->OnPlaceDrag(_thd
.select_method
, _thd
.select_proc
, GetTileBelowCursor());
3402 /* Mouse button released. */
3403 _special_mouse_mode
= WSM_NONE
;
3404 if (_special_mouse_mode
== WSM_DRAGGING
) return ES_HANDLED
;
3406 /* Keep the selected tool, but reset it to the original mode. */
3407 HighLightStyle others
= _thd
.place_mode
& ~(HT_DRAG_MASK
| HT_DIR_MASK
);
3408 if ((_thd
.next_drawstyle
& HT_DRAG_MASK
) == HT_RECT
) {
3409 _thd
.place_mode
= HT_RECT
| others
;
3410 } else if (_thd
.select_method
& VPM_SIGNALDIRS
) {
3411 _thd
.place_mode
= HT_RECT
| others
;
3412 } else if (_thd
.select_method
& VPM_RAILDIRS
) {
3413 _thd
.place_mode
= (_thd
.select_method
& ~VPM_RAILDIRS
) ? _thd
.next_drawstyle
: (HT_RAIL
| others
);
3415 _thd
.place_mode
= HT_POINT
| others
;
3417 SetTileSelectSize(1, 1);
3419 HideMeasurementTooltips();
3420 w
->OnPlaceMouseUp(_thd
.select_method
, _thd
.select_proc
, _thd
.selend
, TileVirtXY(_thd
.selstart
.x
, _thd
.selstart
.y
), TileVirtXY(_thd
.selend
.x
, _thd
.selend
.y
));
3426 * Change the cursor and mouse click/drag handling to a mode for performing special operations like tile area selection, object placement, etc.
3427 * @param icon New shape of the mouse cursor.
3428 * @param pal Palette to use.
3429 * @param mode Mode to perform.
3430 * @param w %Window requesting the mode change.
3432 void SetObjectToPlaceWnd(CursorID icon
, PaletteID pal
, HighLightStyle mode
, Window
*w
)
3434 SetObjectToPlace(icon
, pal
, mode
, w
->window_class
, w
->window_number
);
3437 #include "table/animcursors.h"
3440 * Change the cursor and mouse click/drag handling to a mode for performing special operations like tile area selection, object placement, etc.
3441 * @param icon New shape of the mouse cursor.
3442 * @param pal Palette to use.
3443 * @param mode Mode to perform.
3444 * @param window_class %Window class of the window requesting the mode change.
3445 * @param window_num Number of the window in its class requesting the mode change.
3447 void SetObjectToPlace(CursorID icon
, PaletteID pal
, HighLightStyle mode
, WindowClass window_class
, WindowNumber window_num
)
3449 if (_thd
.window_class
!= WC_INVALID
) {
3450 /* Undo clicking on button and drag & drop */
3451 Window
*w
= _thd
.GetCallbackWnd();
3452 /* Call the abort function, but set the window class to something
3453 * that will never be used to avoid infinite loops. Setting it to
3454 * the 'next' window class must not be done because recursion into
3455 * this function might in some cases reset the newly set object to
3456 * place or not properly reset the original selection. */
3457 _thd
.window_class
= WC_INVALID
;
3459 w
->OnPlaceObjectAbort();
3460 HideMeasurementTooltips();
3464 /* Mark the old selection dirty, in case the selection shape or colour changes */
3465 if ((_thd
.drawstyle
& HT_DRAG_MASK
) != HT_NONE
) SetSelectionTilesDirty();
3467 SetTileSelectSize(1, 1);
3469 _thd
.make_square_red
= false;
3471 if (mode
== HT_DRAG
) { // HT_DRAG is for dragdropping trains in the depot window
3473 _special_mouse_mode
= WSM_DRAGDROP
;
3475 _special_mouse_mode
= WSM_NONE
;
3478 _thd
.place_mode
= mode
;
3479 _thd
.window_class
= window_class
;
3480 _thd
.window_number
= window_num
;
3482 if ((mode
& HT_DRAG_MASK
) == HT_SPECIAL
) { // special tools, like tunnels or docks start with presizing mode
3486 if ((icon
& ANIMCURSOR_FLAG
) != 0) {
3487 SetAnimatedMouseCursor(_animcursors
[icon
& ~ANIMCURSOR_FLAG
]);
3489 SetMouseCursor(icon
, pal
);
3494 /** Reset the cursor and mouse mode handling back to default (normal cursor, only clicking in windows). */
3495 void ResetObjectToPlace()
3497 SetObjectToPlace(SPR_CURSOR_MOUSE
, PAL_NONE
, HT_NONE
, WC_MAIN_WINDOW
, 0);
3500 Point
GetViewportStationMiddle(const Viewport
*vp
, const Station
*st
)
3502 int x
= TileX(st
->xy
) * TILE_SIZE
;
3503 int y
= TileY(st
->xy
) * TILE_SIZE
;
3504 int z
= GetSlopePixelZ(Clamp(x
, 0, Map::SizeX() * TILE_SIZE
- 1), Clamp(y
, 0, Map::SizeY() * TILE_SIZE
- 1));
3506 Point p
= RemapCoords(x
, y
, z
);
3507 p
.x
= UnScaleByZoom(p
.x
- vp
->virtual_left
, vp
->zoom
) + vp
->left
;
3508 p
.y
= UnScaleByZoom(p
.y
- vp
->virtual_top
, vp
->zoom
) + vp
->top
;
3512 /** Helper class for getting the best sprite sorter. */
3513 struct ViewportSSCSS
{
3514 VpSorterChecker fct_checker
; ///< The check function.
3515 VpSpriteSorter fct_sorter
; ///< The sorting function.
3518 /** List of sorters ordered from best to worst. */
3519 static ViewportSSCSS _vp_sprite_sorters
[] = {
3521 { &ViewportSortParentSpritesSSE41Checker
, &ViewportSortParentSpritesSSE41
},
3523 { &ViewportSortParentSpritesChecker
, &ViewportSortParentSprites
}
3526 /** Choose the "best" sprite sorter and set _vp_sprite_sorter. */
3527 void InitializeSpriteSorter()
3529 for (const auto &sprite_sorter
: _vp_sprite_sorters
) {
3530 if (sprite_sorter
.fct_checker()) {
3531 _vp_sprite_sorter
= sprite_sorter
.fct_sorter
;
3535 assert(_vp_sprite_sorter
!= nullptr);
3539 * Scroll players main viewport.
3540 * @param flags type of operation
3541 * @param tile tile to center viewport on
3542 * @param target ViewportScrollTarget of scroll target
3543 * @param ref company or client id depending on the target
3544 * @return the cost of this operation or an error
3546 CommandCost
CmdScrollViewport(DoCommandFlag flags
, TileIndex tile
, ViewportScrollTarget target
, uint32_t ref
)
3548 if (_current_company
!= OWNER_DEITY
) return CMD_ERROR
;
3553 if (_local_company
!= (CompanyID
)ref
) return CommandCost();
3556 if (_network_own_client_id
!= (ClientID
)ref
) return CommandCost();
3562 if (flags
& DC_EXEC
) {
3563 ResetObjectToPlace();
3564 ScrollMainWindowToTile(tile
);
3566 return CommandCost();
3569 void MarkCatchmentTilesDirty()
3571 if (_viewport_highlight_town
!= nullptr) {
3572 MarkWholeScreenDirty();
3575 if (_viewport_highlight_station
!= nullptr) {
3576 if (_viewport_highlight_station
->catchment_tiles
.tile
== INVALID_TILE
) {
3577 MarkWholeScreenDirty();
3578 _viewport_highlight_station
= nullptr;
3580 BitmapTileIterator
it(_viewport_highlight_station
->catchment_tiles
);
3581 for (TileIndex tile
= it
; tile
!= INVALID_TILE
; tile
= ++it
) {
3582 MarkTileDirtyByTile(tile
);
3586 if (_viewport_highlight_waypoint
!= nullptr) {
3587 if (!_viewport_highlight_waypoint
->IsInUse()) {
3588 _viewport_highlight_waypoint
= nullptr;
3590 MarkWholeScreenDirty();
3594 static void SetWindowDirtyForViewportCatchment()
3596 if (_viewport_highlight_station
!= nullptr) SetWindowDirty(WC_STATION_VIEW
, _viewport_highlight_station
->index
);
3597 if (_viewport_highlight_waypoint
!= nullptr) SetWindowDirty(WC_WAYPOINT_VIEW
, _viewport_highlight_waypoint
->index
);
3598 if (_viewport_highlight_town
!= nullptr) SetWindowDirty(WC_TOWN_VIEW
, _viewport_highlight_town
->index
);
3601 static void ClearViewportCatchment()
3603 MarkCatchmentTilesDirty();
3604 _viewport_highlight_station
= nullptr;
3605 _viewport_highlight_waypoint
= nullptr;
3606 _viewport_highlight_town
= nullptr;
3610 * Select or deselect station for coverage area highlight.
3611 * Selecting a station will deselect a town.
3612 * @param *st Station in question
3613 * @param sel Select or deselect given station
3615 void SetViewportCatchmentStation(const Station
*st
, bool sel
)
3617 SetWindowDirtyForViewportCatchment();
3618 if (sel
&& _viewport_highlight_station
!= st
) {
3619 ClearViewportCatchment();
3620 _viewport_highlight_station
= st
;
3621 MarkCatchmentTilesDirty();
3622 } else if (!sel
&& _viewport_highlight_station
== st
) {
3623 MarkCatchmentTilesDirty();
3624 _viewport_highlight_station
= nullptr;
3626 if (_viewport_highlight_station
!= nullptr) SetWindowDirty(WC_STATION_VIEW
, _viewport_highlight_station
->index
);
3630 * Select or deselect waypoint for coverage area highlight.
3631 * Selecting a waypoint will deselect a town.
3632 * @param *wp Waypoint in question
3633 * @param sel Select or deselect given waypoint
3635 void SetViewportCatchmentWaypoint(const Waypoint
*wp
, bool sel
)
3637 SetWindowDirtyForViewportCatchment();
3638 if (sel
&& _viewport_highlight_waypoint
!= wp
) {
3639 ClearViewportCatchment();
3640 _viewport_highlight_waypoint
= wp
;
3641 MarkCatchmentTilesDirty();
3642 } else if (!sel
&& _viewport_highlight_waypoint
== wp
) {
3643 MarkCatchmentTilesDirty();
3644 _viewport_highlight_waypoint
= nullptr;
3646 if (_viewport_highlight_waypoint
!= nullptr) SetWindowDirty(WC_WAYPOINT_VIEW
, _viewport_highlight_waypoint
->index
);
3650 * Select or deselect town for coverage area highlight.
3651 * Selecting a town will deselect a station.
3652 * @param *t Town in question
3653 * @param sel Select or deselect given town
3655 void SetViewportCatchmentTown(const Town
*t
, bool sel
)
3657 SetWindowDirtyForViewportCatchment();
3658 if (sel
&& _viewport_highlight_town
!= t
) {
3659 ClearViewportCatchment();
3660 _viewport_highlight_town
= t
;
3661 MarkWholeScreenDirty();
3662 } else if (!sel
&& _viewport_highlight_town
== t
) {
3663 _viewport_highlight_town
= nullptr;
3664 MarkWholeScreenDirty();
3666 if (_viewport_highlight_town
!= nullptr) SetWindowDirty(WC_TOWN_VIEW
, _viewport_highlight_town
->index
);