| blob | 3df809537537393b8e6b95966fcb5f0e559a72f7 |
1 /* $Id$ */
3 /*
4 * This file is part of OpenTTD.
5 * 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.
6 * 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.
7 * 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/>.
8 */
10 /**
11 * @file viewport.cpp Handling of all viewports.
12 *
13 * \verbatim
14 * The in-game coordinate system looks like this *
15 * *
16 * ^ Z *
17 * | *
18 * | *
19 * | *
20 * | *
21 * / \ *
22 * / \ *
23 * / \ *
24 * / \ *
25 * X < > Y *
26 * \endverbatim
27 */
29 /**
30 * @defgroup vp_column_row Rows and columns in the viewport
31 *
32 * Columns are vertical sections of the viewport that are half a tile wide.
33 * The origin, i.e. column 0, is through the northern and southern most tile.
34 * This means that the column of e.g. Tile(0, 0) and Tile(100, 100) are in
35 * column number 0. The negative columns are towards the left of the screen,
36 * or towards the west, whereas the positive ones are towards respectively
37 * the right and east.
38 * With half a tile wide is meant that the next column of tiles directly west
39 * or east of the centre line are respectively column -1 and 1. Their tile
40 * centers are only half a tile from the center of their adjoining tile when
41 * looking only at the X-coordinate.
42 *
43 * \verbatim
44 * ╳ *
45 * ╱ ╲ *
46 * ╳ 0 ╳ *
47 * ╱ ╲ ╱ ╲ *
48 * ╳-1 ╳ 1 ╳ *
49 * ╱ ╲ ╱ ╲ ╱ ╲ *
50 * ╳-2 ╳ 0 ╳ 2 ╳ *
51 * ╲ ╱ ╲ ╱ ╲ ╱ *
52 * ╳-1 ╳ 1 ╳ *
53 * ╲ ╱ ╲ ╱ *
54 * ╳ 0 ╳ *
55 * ╲ ╱ *
56 * ╳ *
57 * \endverbatim
58 *
59 *
60 * Rows are horizontal sections of the viewport, also half a tile wide.
61 * This time the nothern most tile on the map defines 0 and
62 * everything south of that has a positive number.
63 */
103 #include <map>
104 #include <vector>
105 #include <algorithm>
106 #include <tuple>
117 Point _tile_fract_coords;
120 static const int MAX_TILE_EXTENT_LEFT = ZOOM_LVL_BASE * TILE_PIXELS; ///< Maximum left extent of tile relative to north corner.
121 static const int MAX_TILE_EXTENT_RIGHT = ZOOM_LVL_BASE * TILE_PIXELS; ///< Maximum right extent of tile relative to north corner.
122 static const int MAX_TILE_EXTENT_TOP = ZOOM_LVL_BASE * MAX_BUILDING_PIXELS; ///< Maximum top extent of tile relative to north corner (not considering bridges).
123 static const int MAX_TILE_EXTENT_BOTTOM = ZOOM_LVL_BASE * (TILE_PIXELS + 2 * TILE_HEIGHT); ///< Maximum bottom extent of tile relative to north corner (worst case: #SLOPE_STEEP_N).
126 StringID string;
127 Colours colour;
128 int32 x;
129 int32 y;
131 uint16 width;
132 };
135 SpriteID image;
136 PaletteID pal;
140 };
143 SpriteID image;
144 PaletteID pal;
146 int32 x;
147 int32 y;
149 };
151 /** Enumeration of multi-part foundations */
156 FOUNDATION_PART_END
157 };
159 /**
160 * Mode of "sprite combining"
161 * @see StartSpriteCombine
162 */
166 SPRITE_COMBINE_ACTIVE, ///< %Sprite combining is active. #AddSortableSpriteToDraw outputs child sprites.
167 };
180 RSM_NO_SNAP,
181 RSM_SNAP_TO_TILE,
182 RSM_SNAP_TO_RAIL,
183 };
185 /**
186 * Snapping point for a track.
187 *
188 * Point where a track (rail/road/other) can be snapped to while selecting tracks with polyline
189 * tool (HT_POLY). Besides of x/y coordinates expressed in tile "units" it contains a set of
190 * allowed line directions.
191 */
194 };
198 /** Coordinates of a polyline track made of 2 connected line segments. */
205 };
207 /** Data structure storing rendering information */
209 DrawPixelInfo dpi;
211 StringSpriteToDrawVector string_sprites_to_draw;
212 TileSpriteToDrawVector tile_sprites_to_draw;
213 ParentSpriteToDrawVector parent_sprites_to_draw;
214 ParentSpriteToSortVector parent_sprites_to_sort; ///< Parent sprite pointer array used for sorting
215 ChildScreenSpriteToDrawVector child_screen_sprites_to_draw;
216 TunnelBridgeToMapVector tunnel_to_map;
217 TunnelBridgeToMapVector bridge_to_map;
221 SpriteCombineMode combine_sprites; ///< Current mode of "sprite combining". @see StartSpriteCombine
223 int foundation[FOUNDATION_PART_END]; ///< Foundation sprites (index into parent_sprites_to_draw).
225 int *last_foundation_child[FOUNDATION_PART_END]; ///< Tail of ChildSprite list of the foundations. (index into child_screen_sprites_to_draw)
226 Point foundation_offset[FOUNDATION_PART_END]; ///< Pixel offset for ground sprites on the foundations.
227 };
229 static void MarkViewportDirty(const ViewPort * const vp, int left, int top, int right, int bottom);
238 RouteStepsMap _vp_route_steps;
239 RouteStepsMap _vp_route_steps_last_mark_dirty;
244 SubSprite _vp_route_step_subsprite;
247 TileIndex from_tile;
248 TileIndex to_tile;
252 {
253 return std::tie(this->from_tile, this->to_tile, this->order_match) == std::tie(other.from_tile, other.to_tile, other.order_match);
254 }
257 {
259 }
262 {
263 return std::tie(this->from_tile, this->to_tile, this->order_match) < std::tie(other.from_tile, other.to_tile, other.order_match);
264 }
265 };
272 TileHighlightData _thd;
281 static RailSnapMode _rail_snap_mode = RSM_NO_SNAP; ///< Type of rail track snapping (polyline tool).
282 static LineSnapPoints _tile_snap_points; ///< Tile to which a rail track will be snapped to (polyline tool).
283 static LineSnapPoints _rail_snap_points; ///< Set of points where a rail track will be snapped to (polyline tool).
284 static LineSnapPoint _current_snap_lock; ///< Start point and direction at which selected track is locked on currently (while dragging in polyline mode).
292 {
297 }
300 {
307 }
309 /**
310 * Initialize viewport of the window for use.
311 * @param w Window to use/display the viewport in
312 * @param x Offset of left edge of viewport with respect to left edge window \a w
313 * @param y Offset of top edge of viewport with respect to top edge window \a w
314 * @param width Width of the viewport
315 * @param height Height of the viewport
316 * @param follow_flags Flags controlling the viewport.
317 * - If bit 31 is set, the lower 20 bits are the vehicle that the viewport should follow.
318 * - If bit 31 is clear, it is a #TileIndex.
319 * @param zoom Zoomlevel to display
320 */
323 {
334 vp->zoom = static_cast<ZoomLevel>(Clamp(zoom, _settings_client.gui.zoom_min, _settings_client.gui.zoom_max));
343 Point pt;
359 }
368 }
373 {
386 }
390 DoSetViewportPosition(w, left + (w->left + w->width - left), top, width - (w->left + w->width - left), height);
392 }
398 }
402 DoSetViewportPosition(w, left, top + (w->top + w->height - top), width, height - (w->top + w->height - top));
404 }
407 }
408 }
410 {
415 /* fully_outside */
418 }
429 }
435 }
436 }
437 }
440 {
450 /* Viewport is bound to its left top corner, so it must be rounded down (UnScaleByZoomLower)
451 * else glitch described in FS#1412 will happen (offset by 1 pixel with zoom level > NORMAL)
452 */
474 }
483 }
489 }
490 }
492 /**
493 * Is a xy position inside the viewport of the window?
494 * @param w Window to examine its viewport
495 * @param x X coordinate of the xy position
496 * @param y Y coordinate of the xy position
497 * @return Pointer to the viewport if the xy position is in the viewport of the window,
498 * otherwise \c NULL is returned.
499 */
501 {
510 }
512 /**
513 * Translate screen coordinate in a viewport to a tile coordinate
514 * @param vp Viewport that contains the (\a x, \a y) screen coordinate
515 * @param x Screen x coordinate
516 * @param y Screen y coordinate
517 * @param clamp_to_map Clamp the coordinate outside of the map to the closest tile within the map.
518 * @return Tile coordinate
519 */
521 {
522 Point pt;
530 }
539 /* Bring the coordinates near to a valid range. This is mostly due to the
540 * tiles on the north side of the map possibly being drawn too high due to
541 * the extra height levels. So at the top we allow a number of extra tiles.
542 * This number is based on the tile height and pixels. */
543 int extra_tiles = CeilDiv(_settings_game.construction.max_heightlevel * TILE_HEIGHT, TILE_PIXELS);
546 }
548 /* (a, b) is the X/Y-world coordinate that belongs to (x,y) if the landscape would be completely flat on height 0.
549 * Now find the Z-world coordinate by fix point iteration.
550 * This is a bit tricky because the tile height is non-continuous at foundations.
551 * The clicked point should be approached from the back, otherwise there are regions that are not clickable.
552 * (FOUNDATION_HALFTILE_LOWER on SLOPE_STEEP_S hides north halftile completely)
553 * So give it a z-malus of 4 in the first iterations.
554 */
559 for (int i = 0; i < 5; i++) z = GetSlopePixelZ(Clamp(a + max(z, 4) - 4, min_coord, MapMaxX() * TILE_SIZE - 1), Clamp(b + max(z, 4) - 4, min_coord, MapMaxY() * TILE_SIZE - 1)) / 2;
560 for (int malus = 3; malus > 0; malus--) z = GetSlopePixelZ(Clamp(a + max(z, malus) - malus, min_coord, MapMaxX() * TILE_SIZE - 1), Clamp(b + max(z, malus) - malus, min_coord, MapMaxY() * TILE_SIZE - 1)) / 2;
561 for (int i = 0; i < 5; i++) z = GetSlopePixelZ(Clamp(a + z, min_coord, MapMaxX() * TILE_SIZE - 1), Clamp(b + z, min_coord, MapMaxY() * TILE_SIZE - 1)) / 2;
569 }
572 }
574 /* When used for zooming, check area below current coordinates (x,y)
575 * and return the tile of the zoomed out/in position (zoom_x, zoom_y)
576 * when you just want the tile, make x = zoom_x and y = zoom_y */
578 {
581 Point pt;
589 }
592 {
594 }
598 {
608 }
609 /* Get the tile below the cursor and center on the zoomed-out center */
611 }
613 /**
614 * Update the status of the zoom-buttons according to the zoom-level
615 * of the viewport. This will update their status and invalidate accordingly
616 * @param w Window pointer to the window that has the zoom buttons
617 * @param vp pointer to the viewport whose zoom-level the buttons represent
618 * @param widget_zoom_in widget index for window with zoom-in button
619 * @param widget_zoom_out widget index for window with zoom-out button
620 */
621 void HandleZoomMessage(Window *w, const ViewPort *vp, byte widget_zoom_in, byte widget_zoom_out)
622 {
628 }
630 /**
631 * Schedules a tile sprite for drawing.
632 *
633 * @param image the image to draw.
634 * @param pal the provided palette.
635 * @param x position x (world coordinates) of the sprite.
636 * @param y position y (world coordinates) of the sprite.
637 * @param z position z (world coordinates) of the sprite.
638 * @param sub Only draw a part of the sprite.
639 * @param extra_offs_x Pixel X offset for the sprite position.
640 * @param extra_offs_y Pixel Y offset for the sprite position.
641 */
642 static void AddTileSpriteToDraw(SpriteID image, PaletteID pal, int32 x, int32 y, int z, const SubSprite *sub = NULL, int extra_offs_x = 0, int extra_offs_y = 0)
643 {
653 }
655 /**
656 * Adds a child sprite to the active foundation.
657 *
658 * The pixel offset of the sprite relative to the ParentSprite is the sum of the offset passed to OffsetGroundSprite() and extra_offs_?.
659 *
660 * @param image the image to draw.
661 * @param pal the provided palette.
662 * @param sub Only draw a part of the sprite.
663 * @param foundation_part Foundation part.
664 * @param extra_offs_x Pixel X offset for the sprite position.
665 * @param extra_offs_y Pixel Y offset for the sprite position.
666 */
667 static void AddChildSpriteToFoundation(SpriteID image, PaletteID pal, const SubSprite *sub, FoundationPart foundation_part, int extra_offs_x, int extra_offs_y)
668 {
673 /* Change the active ChildSprite list to the one of the foundation */
677 AddChildSpriteScreen(image, pal, offs.x + extra_offs_x, offs.y + extra_offs_y, false, sub, false);
679 /* Switch back to last ChildSprite list */
681 }
683 /**
684 * Draws a ground sprite at a specific world-coordinate relative to the current tile.
685 * If the current tile is drawn on top of a foundation the sprite is added as child sprite to the "foundation"-ParentSprite.
686 *
687 * @param image the image to draw.
688 * @param pal the provided palette.
689 * @param x position x (world coordinates) of the sprite relative to current tile.
690 * @param y position y (world coordinates) of the sprite relative to current tile.
691 * @param z position z (world coordinates) of the sprite relative to current tile.
692 * @param sub Only draw a part of the sprite.
693 * @param extra_offs_x Pixel X offset for the sprite position.
694 * @param extra_offs_y Pixel Y offset for the sprite position.
695 */
696 void DrawGroundSpriteAt(SpriteID image, PaletteID pal, int32 x, int32 y, int z, const SubSprite *sub, int extra_offs_x, int extra_offs_y)
697 {
698 /* Switch to first foundation part, if no foundation was drawn */
703 AddChildSpriteToFoundation(image, pal, sub, _vd.foundation_part, pt.x + extra_offs_x * ZOOM_LVL_BASE, pt.y + extra_offs_y * ZOOM_LVL_BASE);
705 AddTileSpriteToDraw(image, pal, _cur_ti->x + x, _cur_ti->y + y, _cur_ti->z + z, sub, extra_offs_x * ZOOM_LVL_BASE, extra_offs_y * ZOOM_LVL_BASE);
706 }
707 }
709 /**
710 * Draws a ground sprite for the current tile.
711 * If the current tile is drawn on top of a foundation the sprite is added as child sprite to the "foundation"-ParentSprite.
712 *
713 * @param image the image to draw.
714 * @param pal the provided palette.
715 * @param sub Only draw a part of the sprite.
716 * @param extra_offs_x Pixel X offset for the sprite position.
717 * @param extra_offs_y Pixel Y offset for the sprite position.
718 */
719 void DrawGroundSprite(SpriteID image, PaletteID pal, const SubSprite *sub, int extra_offs_x, int extra_offs_y)
720 {
722 }
724 /**
725 * Called when a foundation has been drawn for the current tile.
726 * Successive ground sprites for the current tile will be drawn as child sprites of the "foundation"-ParentSprite, not as TileSprites.
727 *
728 * @param x sprite x-offset (screen coordinates) of ground sprites relative to the "foundation"-ParentSprite.
729 * @param y sprite y-offset (screen coordinates) of ground sprites relative to the "foundation"-ParentSprite.
730 */
732 {
733 /* Switch to next foundation part */
742 }
744 /* _vd.last_child == NULL if foundation sprite was clipped by the viewport bounds */
745 if (_vd.last_child != NULL) _vd.foundation[_vd.foundation_part] = _vd.parent_sprites_to_draw.Length() - 1;
750 }
752 /**
753 * Adds a child sprite to a parent sprite.
754 * In contrast to "AddChildSpriteScreen()" the sprite position is in world coordinates
755 *
756 * @param image the image to draw.
757 * @param pal the provided palette.
758 * @param x position x of the sprite.
759 * @param y position y of the sprite.
760 * @param z position z of the sprite.
761 * @param sub Only draw a part of the sprite.
762 */
763 static void AddCombinedSprite(SpriteID image, PaletteID pal, int x, int y, int z, const SubSprite *sub)
764 {
776 }
778 /**
779 * Draw a (transparent) sprite at given coordinates with a given bounding box.
780 * 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.
781 * Bounding boxes with bb_offset_x == w or bb_offset_y == h or bb_offset_z == dz are allowed and produce thin slices.
782 *
783 * @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
784 * defined by the sprite offset in the grf file.
785 * However if modifying the sprite offsets is not suitable (e.g. when using existing graphics), the bounding box can be tuned by bb_offset.
786 *
787 * @pre w >= bb_offset_x, h >= bb_offset_y, dz >= bb_offset_z. Else w, h or dz are ignored.
788 *
789 * @param image the image to combine and draw,
790 * @param pal the provided palette,
791 * @param x position X (world) of the sprite,
792 * @param y position Y (world) of the sprite,
793 * @param w bounding box extent towards positive X (world),
794 * @param h bounding box extent towards positive Y (world),
795 * @param dz bounding box extent towards positive Z (world),
796 * @param z position Z (world) of the sprite,
797 * @param transparent if true, switch the palette between the provided palette and the transparent palette,
798 * @param bb_offset_x bounding box extent towards negative X (world),
799 * @param bb_offset_y bounding box extent towards negative Y (world),
800 * @param bb_offset_z bounding box extent towards negative Z (world)
801 * @param sub Only draw a part of the sprite.
802 */
803 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)
804 {
809 /* make the sprites transparent with the right palette */
813 }
818 }
825 /* Compute screen extents of sprite */
837 }
840 /* Compute maximal extents of sprite and its bounding box */
845 }
847 /* Do not add the sprite to the viewport, if it is outside */
853 }
880 }
882 /**
883 * Starts a block of sprites, which are "combined" into a single bounding box.
884 *
885 * Subsequent calls to #AddSortableSpriteToDraw will be drawn into the same bounding box.
886 * That is: The first sprite that is not clipped by the viewport defines the bounding box, and
887 * the following sprites will be child sprites to that one.
888 *
889 * That implies:
890 * - The drawing order is definite. No other sprites will be sorted between those of the block.
891 * - You have to provide a valid bounding box for all sprites,
892 * as you won't know which one is the first non-clipped one.
893 * Preferable you use the same bounding box for all.
894 * - You cannot use #AddChildSpriteScreen inside the block, as its result will be indefinite.
895 *
896 * The block is terminated by #EndSpriteCombine.
897 *
898 * You cannot nest "combined" blocks.
899 */
901 {
904 }
906 /**
907 * Terminates a block of sprites started by #StartSpriteCombine.
908 * Take a look there for details.
909 */
911 {
914 }
916 /**
917 * Check if the parameter "check" is inside the interval between
918 * begin and end, including both begin and end.
919 * @note Whether \c begin or \c end is the biggest does not matter.
920 * This method will account for that.
921 * @param begin The begin of the interval.
922 * @param end The end of the interval.
923 * @param check The value to check.
924 */
926 {
929 }
931 /**
932 * Checks whether a point is inside the selected rectangle given by _thd.size, _thd.pos and _thd.diagonal
933 * @param x The x coordinate of the point to be checked.
934 * @param y The y coordinate of the point to be checked.
935 * @return True if the point is inside the rectangle, else false.
936 */
938 {
941 }
945 int a = ((x - _thd.pos.x) + (y - _thd.pos.y)); // Rotated coordinate system for the point under scrutiny.
948 /* Check if a and b are between 0 and dist_a or dist_b respectively. */
950 }
952 /**
953 * Add a child sprite to a parent sprite.
954 *
955 * @param image the image to draw.
956 * @param pal the provided palette.
957 * @param x sprite x-offset (screen coordinates) relative to parent sprite.
958 * @param y sprite y-offset (screen coordinates) relative to parent sprite.
959 * @param transparent if true, switch the palette between the provided palette and the transparent palette,
960 * @param sub Only draw a part of the sprite.
961 */
962 void AddChildSpriteScreen(SpriteID image, PaletteID pal, int x, int y, bool transparent, const SubSprite *sub, bool scale)
963 {
966 /* If the ParentSprite was clipped by the viewport bounds, do not draw the ChildSprites either */
969 /* make the sprites transparent with the right palette */
973 }
985 /* Append the sprite to the active ChildSprite list.
986 * If the active ParentSprite is a foundation, update last_foundation_child as well.
987 * Note: ChildSprites of foundations are NOT sequential in the vector, as selection sprites are added at last. */
991 }
993 static void AddStringToDraw(int x, int y, StringID string, uint64 params_1, uint64 params_2, Colours colour, uint16 width)
994 {
1004 }
1007 /**
1008 * Draws sprites between ground sprite and everything above.
1009 *
1010 * The sprite is either drawn as TileSprite or as ChildSprite of the active foundation.
1011 *
1012 * @param image the image to draw.
1013 * @param pal the provided palette.
1014 * @param ti TileInfo Tile that is being drawn
1015 * @param z_offset Z offset relative to the groundsprite. Only used for the sprite position, not for sprite sorting.
1016 * @param foundation_part Foundation part the sprite belongs to.
1017 */
1018 static void DrawSelectionSprite(SpriteID image, PaletteID pal, const TileInfo *ti, int z_offset, FoundationPart foundation_part)
1019 {
1020 /* FIXME: This is not totally valid for some autorail highlights that extend over the edges of the tile. */
1022 /* draw on real ground */
1025 /* draw on top of foundation */
1027 }
1028 }
1030 /**
1031 * Draws a selection rectangle on a tile.
1032 *
1033 * @param ti TileInfo Tile that is being drawn
1034 * @param pal Palette to apply.
1035 */
1037 {
1040 SpriteID sel;
1050 sel = ((ti->tileh & SlopeWithOneCornerRaised(opposite_corner)) != 0 ? SPR_HALFTILE_SELECTION_UP : SPR_HALFTILE_SELECTION_FLAT);
1051 }
1055 }
1057 }
1059 static HighLightStyle GetPartOfAutoLine(int px, int py, const Point &selstart, const Point &selend, HighLightStyle dir)
1060 {
1061 if (!IsInRangeInclusive(selstart.x & ~TILE_UNIT_MASK, selend.x & ~TILE_UNIT_MASK, px)) return HT_DIR_END;
1062 if (!IsInRangeInclusive(selstart.y & ~TILE_UNIT_MASK, selend.y & ~TILE_UNIT_MASK, py)) return HT_DIR_END;
1070 case HT_DIR_HU: return (px == -py) ? HT_DIR_HU : (px == -py - (int)TILE_SIZE) ? HT_DIR_HL : HT_DIR_END;
1071 case HT_DIR_HL: return (px == -py) ? HT_DIR_HL : (px == -py + (int)TILE_SIZE) ? HT_DIR_HU : HT_DIR_END;
1072 case HT_DIR_VL: return (px == py) ? HT_DIR_VL : (px == py + (int)TILE_SIZE) ? HT_DIR_VR : HT_DIR_END;
1073 case HT_DIR_VR: return (px == py) ? HT_DIR_VR : (px == py - (int)TILE_SIZE) ? HT_DIR_VL : HT_DIR_END;
1075 }
1078 }
1082 /**
1083 * Draws autorail highlights.
1084 *
1085 * @param *ti TileInfo Tile that is being drawn
1086 * @param autorail_type \c HT_DIR_XXX, offset into _AutorailTilehSprite[][]
1087 * @param pal Palette to use, -1 to autodetect
1088 */
1089 static void DrawAutorailSelection(const TileInfo *ti, HighLightStyle autorail_type, PaletteID pal = -1)
1090 {
1091 SpriteID image;
1097 static const HighLightStyle _lower_rail[CORNER_END] = { HT_DIR_VR, HT_DIR_HU, HT_DIR_VL, HT_DIR_HL }; // CORNER_W, CORNER_S, CORNER_E, CORNER_N
1101 /* Here we draw the highlights of the "three-corners-raised"-slope. That looks ok to me. */
1103 }
1104 }
1114 }
1117 }
1119 /**
1120 * Checks if the specified tile is selected and if so draws selection using correct selectionstyle.
1121 * @param *ti TileInfo Tile that is being drawn
1122 */
1124 {
1125 /* Draw a red error square? */
1137 /* Check if it's inside the outer area? */
1140 /* Draw a blue rect. */
1142 }
1143 }
1148 /* Figure out the Z coordinate for the single dot. */
1154 }
1161 }
1162 }
1163 DrawSelectionSprite(_cur_dpi->zoom <= ZOOM_LVL_DETAIL ? SPR_DOT : SPR_DOT_SMALL, PAL_NONE, ti, z, foundation_part);
1164 }
1171 }
1175 HighLightStyle type = GetPartOfAutoLine(ti->x, ti->y, _thd.selstart, _thd.selend, _thd.drawstyle & HT_DIR_MASK);
1181 }
1183 }
1184 }
1185 }
1187 /**
1188 * Returns the y coordinate in the viewport coordinate system where the given
1189 * tile is painted.
1190 * @param tile Any tile.
1191 * @return The viewport y coordinate where the tile is painted.
1192 */
1194 {
1195 /* Each increment in X or Y direction moves down by half a tile, i.e. TILE_PIXELS / 2. */
1196 return (tile.y * (int)(TILE_PIXELS / 2) + tile.x * (int)(TILE_PIXELS / 2) - TilePixelHeightOutsideMap(tile.x, tile.y)) << ZOOM_LVL_SHIFT;
1197 }
1199 /**
1200 * Add the landscape to the viewport, i.e. all ground tiles and buildings.
1201 */
1203 {
1210 /* Transformations between tile coordinates and viewport rows/columns: See vp_column_row
1211 * column = y - x
1212 * row = x + y
1213 * x = (row - column) / 2
1214 * y = (row + column) / 2
1215 * Note: (row, columns) pairs are only valid, if they are both even or both odd.
1216 */
1218 /* Columns overlap with neighbouring columns by a half tile.
1219 * - Left column is column of upper_left (rounded down) and one column to the left.
1220 * - Right column is column of upper_right (rounded up) and one column to the right.
1221 * Note: Integer-division does not round down for negative numbers, so ensure rounding with another increment/decrement.
1222 */
1226 int potential_bridge_height = ZOOM_LVL_BASE * TILE_HEIGHT * _settings_game.construction.max_bridge_height;
1228 /* Rows overlap with neighbouring rows by a half tile.
1229 * The first row that could possibly be visible is the row above upper_left (if it is at height 0).
1230 * Due to integer-division not rounding down for negative numbers, we need another decrement.
1231 */
1237 /* Valid row/column? */
1240 Point tilecoord;
1246 TileType tile_type;
1247 TileInfo tile_info;
1253 /* This includes the south border at MapMaxX / MapMaxY. When terraforming we still draw tile selections there. */
1259 }
1262 /* We are inside the map => paint landscape. */
1265 /* We are outside the map => paint black. */
1267 }
1272 /* The tile in this column is not visible yet.
1273 * Tiles in other columns may be visible, but we need more rows in any case. */
1276 }
1282 /* Is tile with buildings visible? */
1286 /* Is the bridge visible? */
1288 int bridge_height = ZOOM_LVL_BASE * (GetBridgePixelHeight(bridge_tile) - TilePixelHeight(tile_info.tile));
1290 }
1292 /* Would a higher bridge on a more southern tile be visible?
1293 * If yes, we need to loop over more rows to possibly find one. */
1296 /* Outside of map. If we are on the north border of the map, there may still be a bridge visible,
1297 * so we need to loop over more rows to possibly find one. */
1298 if ((tilecoord.x <= 0 || tilecoord.y <= 0) && min_visible_height < potential_bridge_height + MAX_TILE_EXTENT_TOP) last_row = false;
1299 }
1313 }
1314 }
1315 }
1316 }
1317 }
1319 /**
1320 * Add a string to draw in the viewport
1321 * @param dpi current viewport area
1322 * @param small_from Zoomlevel from when the small font should be used
1323 * @param sign sign position and dimension
1324 * @param string_normal String for normal and 2x zoom level
1325 * @param string_small String for 4x and 8x zoom level
1326 * @param string_small_shadow Shadow string for 4x and 8x zoom level; or #STR_NULL if no shadow
1327 * @param colour colour of the sign background; or INVALID_COLOUR if transparent
1328 */
1329 void ViewportAddString(const DrawPixelInfo *dpi, ZoomLevel small_from, const ViewportSign *sign, StringID string_normal, StringID string_small, StringID string_small_shadow, uint64 params_1, uint64 params_2, Colours colour)
1330 {
1339 int sign_half_width = ScaleByZoom((small ? sign->width_small : sign->width_normal) / 2, dpi->zoom);
1346 }
1349 AddStringToDraw(sign->center - sign_half_width, sign->top, string_normal, params_1, params_2, colour, sign->width_normal);
1354 AddStringToDraw(sign->center - sign_half_width + shadow_offset, sign->top, string_small_shadow, params_1, params_2, INVALID_COLOUR, sign->width_small);
1355 }
1356 AddStringToDraw(sign->center - sign_half_width, sign->top - shadow_offset, string_small, params_1, params_2,
1358 }
1359 }
1366 {
1369 }
1372 {
1374 }
1375 };
1378 {
1389 }
1390 }
1393 /**
1394 * Check whether to show a sign above a given station/waypoint.
1395 * @param st Pointer to the station/waypoint.
1396 * @return Whether the sign should be shown.
1397 */
1399 {
1400 /* Don't draw if the display options are disabled */
1401 return HasBit(_display_opt, Station::IsExpected(st) ? DO_SHOW_STATION_NAMES : DO_SHOW_WAYPOINT_NAMES) &&
1402 /* Don't draw if station is owned by another company and competitor station names are hidden. Stations owned by none are never ignored. */
1403 (HasBit(_display_opt, DO_SHOW_COMPETITOR_SIGNS) || _local_company == st->owner || st->owner == OWNER_NONE);
1404 }
1408 {
1409 if (!(HasBit(_display_opt, DO_SHOW_STATION_NAMES) || HasBit(_display_opt, DO_SHOW_WAYPOINT_NAMES)) || _game_mode == GM_MENU) return;
1421 ViewportAddString(dpi, ZOOM_LVL_OUT_16X, &st->sign, str, str + 1, STR_NULL, st->index, st->facilities,
1423 }
1424 }
1428 {
1429 /* Signs are turned off or are invisible */
1436 /* Don't draw if sign is owned by another company and competitor signs should be hidden.
1437 * Note: It is intentional that also signs owned by OWNER_NONE are hidden. Bankrupt
1438 * companies can leave OWNER_NONE signs after them. */
1439 if (!HasBit(_display_opt, DO_SHOW_COMPETITOR_SIGNS) && _local_company != si->owner && si->owner != OWNER_DEITY) continue;
1444 STR_WHITE_SIGN,
1445 (IsTransparencySet(TO_SIGNS) || si->owner == OWNER_DEITY) ? STR_VIEWPORT_SIGN_SMALL_WHITE : STR_VIEWPORT_SIGN_SMALL_BLACK, STR_NULL,
1446 si->index, 0, (si->owner == OWNER_NONE) ? COLOUR_GREY : (si->owner == OWNER_DEITY ? INVALID_COLOUR : _company_colours[si->owner]));
1447 }
1448 }
1450 /**
1451 * Update the position of the viewport sign.
1452 * @param center the (preferred) center of the viewport sign
1453 * @param top the new top of the sign
1454 * @param str the string to show in the sign
1455 * @param str_small the string to show when zoomed out. STR_NULL means same as \a str
1456 */
1458 {
1469 /* zoomed out version */
1472 }
1473 this->width_small = VPSM_LEFT + Align(GetStringBoundingBox(buffer, FS_SMALL).width, 2) + VPSM_RIGHT;
1476 }
1478 /**
1479 * Mark the sign dirty in all viewports.
1480 * @param maxzoom Maximum %ZoomLevel at which the text is visible.
1481 *
1482 * @ingroup dirty
1483 */
1485 {
1489 /* FIXME: This doesn't switch to width_small when appropriate. */
1493 zoomlevels[zoom].bottom = this->top + ScaleByZoom(VPSM_TOP + FONT_HEIGHT_NORMAL + VPSM_BOTTOM + 1, zoom);
1494 }
1500 }
1501 }
1502 }
1505 {
1509 }
1510 }
1512 /** This fallback sprite checker always exists. */
1514 {
1516 }
1518 /** Sort parent sprites pointer array */
1520 {
1527 psd++;
1529 }
1538 /* Decide which comparator to use, based on whether the bounding
1539 * boxes overlap
1540 */
1544 /* Use X+Y+Z as the sorting order, so sprites closer to the bottom of
1545 * the screen and with higher Z elevation, are drawn in front.
1546 * Here X,Y,Z are the coordinates of the "center of mass" of the sprite,
1547 * i.e. X=(left+right)/2, etc.
1548 * However, since we only care about order, don't actually divide / 2
1549 */
1553 }
1555 /* We only change the order, if it is definite.
1556 * I.e. every single order of X, Y, Z says ps2 is behind ps or they overlap.
1557 * That is: If one partial order says ps behind ps2, do not change the order.
1558 */
1563 }
1564 }
1566 /* Move ps2 in front of ps */
1570 }
1572 }
1573 }
1574 }
1576 static void ViewportDrawParentSprites(const ParentSpriteToSortVector *psd, const ChildScreenSpriteToDrawVector *csstdv)
1577 {
1581 if (ps->image != SPR_EMPTY_BOUNDING_BOX) DrawSpriteViewport(ps->image, ps->pal, ps->x, ps->y, ps->sub);
1588 }
1589 }
1590 }
1592 /**
1593 * Draws the bounding boxes of all ParentSprites
1594 * @param psd Array of ParentSprites
1595 */
1597 {
1610 }
1611 }
1614 {
1618 /* No need to bother for hidden things */
1624 }
1630 /* Check if already stored */
1631 TunnelBridgeToMapVector * const tbtmv = tile_is_tunnel ? &_vd.tunnel_to_map : &_vd.bridge_to_map;
1636 tbtm++;
1637 }
1639 /* It's a new one, add it to the list */
1643 /* ensure deterministic ordering, to avoid render flicker */
1650 }
1651 }
1654 {
1656 }
1659 {
1664 tbtm--;
1665 }
1666 }
1667 }
1669 /**
1670 * Draw/colour the blocks that have been redrawn.
1671 */
1673 {
1689 }
1692 {
1706 /* Do not draw signs nor station names if they are set invisible */
1710 /* Don't draw the rectangle.
1711 * Real colours need the TC_IS_PALETTE_COLOUR flag.
1712 * Otherwise colours from _string_colourmap are assumed. */
1715 /* Draw the rectangle if 'transparent station signs' is off,
1716 * or if we are drawing a general text sign (STR_WHITE_SIGN). */
1720 );
1721 }
1722 }
1724 DrawString(x + VPSM_LEFT, x + w - 1 - VPSM_RIGHT, y + VPSM_TOP, ss->string, colour, SA_HOR_CENTER);
1725 }
1726 }
1729 {
1748 }
1749 }
1751 }
1754 {
1768 }
1769 }
1771 }
1774 {
1781 }
1783 }
1786 {
1805 if (ot == OT_GOTO_STATION || ot == OT_GOTO_DEPOT || ot == OT_GOTO_WAYPOINT || ot == OT_IMPLICIT) from_tile = to_tile;
1806 }
1807 // remove duplicate lines
1809 _vp_route_paths.erase(std::unique(_vp_route_paths.begin(), _vp_route_paths.end()), _vp_route_paths.end());
1810 }
1812 }
1814 /** Draw the route of a vehicle. */
1816 {
1821 // make sure we remove any leftover paths
1826 }
1828 }
1831 /* case 0: return; // No */
1835 // make sure we remove any leftover paths
1839 }
1841 }
1847 const Point from_pt = RemapCoords2(TileX(iter.from_tile) * TILE_SIZE + TILE_SIZE / 2, TileY(iter.from_tile) * TILE_SIZE + TILE_SIZE / 2);
1851 const Point to_pt = RemapCoords2(TileX(iter.to_tile) * TILE_SIZE + TILE_SIZE / 2, TileY(iter.to_tile) * TILE_SIZE + TILE_SIZE / 2);
1857 GfxDrawLine(from_x, from_y, to_x, to_y, PC_BLACK, 3, _settings_client.gui.dash_level_of_route_lines);
1859 }
1860 GfxDrawLine(from_x, from_y, to_x, to_y, iter.order_match ? PC_WHITE : PC_YELLOW, line_width, _settings_client.gui.dash_level_of_route_lines);
1861 }
1864 // make sure we're not drawing a partial path
1868 }
1872 }
1873 }
1874 }
1876 static inline void DrawRouteStep(const ViewPort * const vp, const TileIndex tile, const RankOrderTypeList list)
1877 {
1880 const Point pt = RemapCoords2(TileX(tile) * TILE_SIZE + TILE_SIZE / 2, TileY(tile) * TILE_SIZE + TILE_SIZE / 2);
1881 const int x = UnScaleByZoomLower(pt.x - _vd.dpi.left, _vd.dpi.zoom) - (_vp_route_step_width / 2);
1883 const int rsth = _vp_route_step_height_top + (int)step_count * char_height + _vp_route_step_height_bottom;
1886 /* Draw the background. */
1891 DrawSprite(SPR_ROUTE_STEP_MIDDLE, PAL_NONE, _cur_dpi->left + x, _cur_dpi->top + y2, &_vp_route_step_subsprite);
1892 }
1896 DrawSprite(SetBit(s, PALETTE_MODIFIER_TRANSPARENT), PALETTE_TO_TRANSPARENT, _cur_dpi->left + x, _cur_dpi->top + y2);
1898 /* Fill with the data. */
1904 /* Write order overflow item */
1906 DrawString(_dpi_for_text.left + x, _dpi_for_text.left + x + _vp_route_step_width - 1, _dpi_for_text.top + y2,
1909 for (RankOrderTypeList::const_iterator cit = list.begin(); cit != list.end(); cit++, y2 += char_height) {
1927 }
1929 /* Write order's info */
1931 DrawString(_dpi_for_text.left + x, _dpi_for_text.left + x + _vp_route_step_width - 1, _dpi_for_text.top + y2,
1933 }
1934 }
1935 }
1937 }
1940 {
1944 /* Prepare data. */
1949 order_rank++;
1952 }
1953 }
1956 }
1958 /** Draw the route steps of a vehicle. */
1960 {
1964 for (RouteStepsMap::const_iterator cit = _vp_route_steps.begin(); cit != _vp_route_steps.end(); cit++) {
1966 }
1968 }
1970 for (RouteStepsMap::const_iterator cit = _vp_route_steps.begin(); cit != _vp_route_steps.end(); cit++) {
1972 }
1973 }
1974 }
1977 {
1989 const Point from_pt = RemapCoords2(TileX(from_tile) * TILE_SIZE + TILE_SIZE / 2, TileY(from_tile) * TILE_SIZE + TILE_SIZE / 2);
1994 const Point to_pt = RemapCoords2(TileX(to_tile) * TILE_SIZE + TILE_SIZE / 2, TileY(to_tile) * TILE_SIZE + TILE_SIZE / 2);
2001 }
2004 }
2005 }
2006 }
2007 }
2012 const Point from_pt = RemapCoords2(TileX(from_tile) * TILE_SIZE + TILE_SIZE / 2, TileY(from_tile) * TILE_SIZE + TILE_SIZE / 2);
2017 const Point to_pt = RemapCoords2(TileX(to_tile) * TILE_SIZE + TILE_SIZE / 2, TileY(to_tile) * TILE_SIZE + TILE_SIZE / 2);
2022 }
2023 }
2026 }
2028 #define SLOPIFY_COLOUR(tile, height, vF, vW, vS, vE, vN, action) { \
2029 if (show_slope) { \
2030 const Slope slope = GetTileSlope((tile), (height)); \
2031 switch (slope) { \
2032 case SLOPE_FLAT: \
2033 case SLOPE_ELEVATED: \
2034 action (vF); break; \
2035 default: { \
2036 switch (slope & SLOPE_EW) { \
2037 case SLOPE_W: action (vW); break; \
2038 case SLOPE_E: action (vE); break; \
2039 default: action (slope & SLOPE_S) ? (vS) : (vN); break; \
2040 } \
2041 break; \
2042 } \
2043 } \
2044 } else { \
2045 action (vF); \
2046 } \
2047 }
2048 #define RETURN_SLOPIFIED_COLOUR(tile, height, colour, colour_light, colour_dark) SLOPIFY_COLOUR(tile, height, colour, colour_light, colour_dark, colour_dark, colour_light, return)
2049 #define ASSIGN_SLOPIFIED_COLOUR(tile, height, colour, colour_light, colour_dark, to_var) SLOPIFY_COLOUR(tile, height, colour, colour_light, colour_dark, colour_dark, colour_light, to_var =)
2050 #define GET_SLOPE_INDEX(slope_index) SLOPIFY_COLOUR(tile, NULL, 0, 1, 2, 3, 4, slope_index =)
2052 #define COL8TO32(x) _cur_palette.palette[x].data
2053 #define COLOUR_FROM_INDEX(x) ((const uint8 *)&(x))[colour_index]
2054 #define IS32(x) (is_32bpp ? COL8TO32(x) : (x))
2056 /* Variables containing Colour if 32bpp or palette index if 8bpp. */
2057 uint32 _vp_map_vegetation_clear_colours[16][6][8]; ///< [Slope][ClearGround][Multi (see LoadClearGroundMainColours())]
2058 uint32 _vp_map_vegetation_tree_colours[5][MAX_TREE_COUNT_BY_LANDSCAPE]; ///< [TreeGround][max of _tree_count_by_landscape]
2062 {
2075 }
2076 }
2081 CLEAR_SNOW, // TREE_GROUND_SNOW_DESERT, make it +1 if _settings_game.game_creation.landscape == LT_TROPIC
2083 CLEAR_SNOW, // TREE_GROUND_ROUGH_SNOW, make it +1 if _settings_game.game_creation.landscape == LT_TROPIC
2084 };
2087 static inline uint32 ViewportMapGetColourVegetation(const TileIndex tile, TileType t, const uint colour_index)
2088 {
2089 uint32 colour;
2093 uint multi;
2098 }
2101 }
2112 if (cg == CLEAR_SNOW && _settings_game.game_creation.landscape == LT_TROPIC) cg = CLEAR_DESERT;
2117 /* Like ground. */
2119 }
2121 /* Take ground and make it darker. */
2124 }
2126 /* 8bpp transparent snow trees give blue. Definitely don't want that. Prefer grey. */
2129 }
2130 }
2133 return _vp_map_vegetation_clear_colours[colour_index][_settings_game.game_creation.landscape == LT_TROPIC ? CLEAR_DESERT : CLEAR_SNOW][td];
2134 }
2136 const uint rnd = min(GetTreeCount(tile) ^ (((tile & 3) ^ (TileY(tile) & 3)) * td), MAX_TREE_COUNT_BY_LANDSCAPE - 1);
2138 }
2139 }
2140 }
2147 }
2148 /* FALL THROUGH */
2154 }
2158 }
2160 if (show_slope) ASSIGN_SLOPIFIED_COLOUR(tile, NULL, colour, _lighten_colour[colour], _darken_colour[colour], colour);
2162 }
2163 }
2166 static inline uint32 ViewportMapGetColourIndustries(const TileIndex tile, const TileType t, const uint colour_index)
2167 {
2174 /* If industry is allowed to be seen, use its colour on the map. */
2178 /* Otherwise, return the colour which will make it disappear. */
2180 }
2184 if (t != MP_INDUSTRY && GetWaterTileType(tile) != WATER_TILE_COAST) GET_SLOPE_INDEX(slope_index); ///< Ignore industry on water not shown on map.
2186 }
2189 const SmallMapColourScheme * const cs = &_heightmap_schemes[_settings_client.gui.smallmap_land_colour];
2190 const uint32 colours = ApplyMask(_smallmap_show_heightmap ? cs->height_colours[h] : cs->default_colour, &_smallmap_vehicles_andor[t2]);
2193 if (show_slope) ASSIGN_SLOPIFIED_COLOUR(tile, NULL, colour, _lighten_colour[colour], _darken_colour[colour], colour);
2196 }
2199 static inline uint32 ViewportMapGetColourOwner(const TileIndex tile, TileType t, const uint colour_index)
2200 {
2208 }
2211 if ((o < MAX_COMPANIES && !_legend_land_owners[_company_to_list_pos[o]].show_on_map) || o == OWNER_NONE || o == OWNER_WATER) {
2217 }
2220 }
2221 }
2224 uint32 colour = COLOUR_FROM_INDEX(_heightmap_schemes[_settings_client.gui.smallmap_land_colour].height_colours[h]);
2225 if (show_slope) ASSIGN_SLOPIFIED_COLOUR(tile, NULL, colour, _lighten_colour[colour], _darken_colour[colour], colour);
2228 }
2231 }
2233 /* Train stations are sometimes hard to spot.
2234 * So we give the player a hint by mixing his colour with black. */
2237 if (show_slope) ASSIGN_SLOPIFIED_COLOUR(tile, NULL, colour, _lighten_colour[colour], _darken_colour[colour], colour);
2238 }
2241 }
2244 }
2246 static inline void ViewportMapStoreBridgeAboveTile(const ViewPort * const vp, const TileIndex tile)
2247 {
2248 /* No need to bother for hidden things */
2251 /* Check existing stored bridges */
2262 }
2266 }
2267 }
2270 }
2272 static inline TileIndex ViewportMapGetMostSignificantTileType(const ViewPort * const vp, const TileIndex from_tile, TileType * const tile_type)
2273 {
2276 /* Store bridges and tunnels. */
2280 }
2287 }
2288 }
2290 }
2296 /* Find the most important tile of the area. */
2305 }
2308 }
2309 }
2311 /* Store bridges and tunnels. */
2319 }
2320 }
2323 }
2325 /** Get the colour of a tile, can be 32bpp RGB or 8bpp palette index. */
2327 uint32 ViewportMapGetColour(const ViewPort * const vp, uint x, uint y, const uint colour_index)
2328 {
2333 /* Very approximative but fast way to get the tile when taking Z into account. */
2339 /* tile_tmp and tile must be from the same side,
2340 * otherwise it's an approximation erroneous case
2341 * that leads to a graphic glitch below south west border.
2342 */
2346 }
2351 /* Return the colours. */
2353 default: return ViewportMapGetColourOwner<is_32bpp, show_slope>(tile, tile_type, colour_index);
2354 case VPMT_INDUSTRY: return ViewportMapGetColourIndustries<is_32bpp, show_slope>(tile, tile_type, colour_index);
2355 case VPMT_VEGETATION: return ViewportMapGetColourVegetation<is_32bpp, show_slope>(tile, tile_type, colour_index);
2356 }
2357 }
2359 /* Taken from http://stereopsis.com/doubleblend.html, PixelBlend() is faster than ComposeColourRGBANoCheck() */
2361 {
2376 }
2378 /** Draw the bounding boxes of the scrolling viewport (right-clicked and dragged) */
2380 {
2384 /* Check intersection of dpi and vp_scrolling */
2387 const int vp_scrolling_virtual_bottom_mask = (vp_scrolling->virtual_top + vp_scrolling->virtual_height) & mask;
2392 const int vp_scrolling_virtual_right_mask = (vp_scrolling->virtual_left + vp_scrolling->virtual_width) & mask;
2396 /* OK, so we can draw something that tells where the scrolling viewport is */
2403 /* If asked, with 32bpp we can do some blending */
2404 if (_settings_client.gui.show_scrolling_viewport_on_map >= 2 && blitter->GetScreenDepth() == 32)
2409 /* Draw area contour */
2423 }
2424 }
2425 }
2426 }
2427 }
2428 }
2432 static void ViewportMapDrawBridgeTunnel(const ViewPort * const vp, const TunnelBridgeToMap * const tbtm, const int z,
2434 {
2442 uint8 colour;
2443 if (vp->map_type == VPMT_OWNER && _settings_client.gui.use_owner_colour_for_tunnelbridge && o < MAX_COMPANIES) {
2446 }
2449 }
2458 }
2459 }
2460 }
2462 /** Draw the map on a viewport. */
2465 {
2471 /* Index of colour: _green_map_heights[] contains blocks of 4 colours, say ABCD
2472 * For a XXXY colour block to render nicely, follow the model:
2473 * line 1: ABCDABCDABCD
2474 * line 2: CDABCDABCDAB
2475 * line 3: ABCDABCDABCD
2476 * => colour_index_base's second bit is changed every new line.
2477 */
2491 /* Render base map. */
2503 vp_map_line_ptr32++;
2504 }
2507 vp_map_line_ptr8++;
2508 }
2515 }
2518 }
2522 /* Render tunnels */
2525 for (const TunnelBridgeToMap *tbtm = _vd.tunnel_to_map.Begin(); tbtm != tbtm_end; tbtm++) { // For each tunnel
2527 const Point pt_from = RemapCoords(TileX(tbtm->from_tile) * TILE_SIZE, TileY(tbtm->from_tile) * TILE_SIZE, tunnel_z);
2528 const Point pt_to = RemapCoords(TileX(tbtm->to_tile) * TILE_SIZE, TileY(tbtm->to_tile) * TILE_SIZE, tunnel_z);
2530 /* check if tunnel is wholly outside redrawing area */
2539 }
2540 }
2542 /* Render bridges */
2545 for (const TunnelBridgeToMap *tbtm = _vd.bridge_to_map.Begin(); tbtm != tbtm_end; tbtm++) { // For each bridge
2546 ViewportMapDrawBridgeTunnel(vp, tbtm, (GetBridgeHeight(tbtm->from_tile) - 1) * TILE_HEIGHT, false, w, h, blitter);
2547 }
2548 }
2549 }
2552 {
2571 _vd.dpi.dst_ptr = BlitterFactory::GetCurrentBlitter()->MoveTo(old_dpi->dst_ptr, x - old_dpi->left, y - old_dpi->top);
2581 /* Here the rendering is like smallmap. */
2585 }
2587 _pal2trsp_remap_ptr = IsTransparencySet(TO_TREES) ? GetNonSprite(GB(PALETTE_TO_TRANSPARENT, 0, PALETTE_WIDTH), ST_RECOLOUR) + 1 : NULL;
2590 }
2592 if (_scrolling_viewport && _settings_client.gui.show_scrolling_viewport_on_map) ViewportMapDrawScrollingViewportBox(vp);
2594 }
2596 /* Classic rendering. */
2606 if (_vd.tile_sprites_to_draw.Length() != 0) ViewportDrawTileSprites(&_vd.tile_sprites_to_draw);
2611 }
2617 }
2627 if (vp->overlay != NULL && vp->overlay->GetCargoMask() != 0 && vp->overlay->GetCompanyMask() != 0) {
2628 /* translate to window coordinates */
2632 }
2636 /* translate to world coordinates */
2640 }
2652 }
2654 /**
2655 * Make sure we don't draw a too big area at a time.
2656 * If we do, the sprite sorter will run into major performance problems and the sprite memory may overflow.
2657 */
2659 {
2660 if ((vp->zoom < ZOOM_LVL_DRAW_MAP) && (ScaleByZoom(bottom - top, vp->zoom) * ScaleByZoom(right - left, vp->zoom) > 180000 * ZOOM_LVL_BASE * ZOOM_LVL_BASE)) {
2669 }
2676 );
2677 }
2678 }
2681 {
2695 }
2697 /**
2698 * Draw the viewport of this window.
2699 */
2701 {
2707 ViewportDraw(this->viewport, dpi->left, dpi->top, dpi->left + dpi->width, dpi->top + dpi->height);
2711 }
2713 /**
2714 * Continue criteria for the SearchMapEdge function.
2715 * @param iter Value to check.
2716 * @param iter_limit Maximum value for the iter
2717 * @param sy Screen y coordinate calculated for the tile at hand
2718 * @param sy_limit Limit to the screen y coordinate
2719 * @return True when we should continue searching.
2720 */
2723 /** Continue criteria for searching a no-longer-visible tile in negative direction, starting at some tile. */
2724 static inline bool ContinueLowerMapEdgeSearch(int iter, int iter_limit, int sy, int sy_limit) { return iter > 0 && sy > sy_limit; }
2725 /** Continue criteria for searching a no-longer-visible tile in positive direction, starting at some tile. */
2726 static inline bool ContinueUpperMapEdgeSearch(int iter, int iter_limit, int sy, int sy_limit) { return iter < iter_limit && sy < sy_limit; }
2728 /**
2729 * Searches, starting at the given tile, by applying the given offset to iter, for a no longer visible tile.
2730 * The whole sense of this function is keeping the to-be-written code small, thus it is a little bit abstracted
2731 * so the same function can be used for both the X and Y locations. As such a reference to one of the elements
2732 * in curr_tile was needed.
2733 * @param curr_tile A tile
2734 * @param iter Reference to either the X or Y of curr_tile.
2735 * @param iter_limit Upper search limit for the iter value.
2736 * @param offset Search in steps of this size
2737 * @param sy_limit Search limit to be passed to the criteria
2738 * @param continue_criteria Search as long as this criteria is true
2739 * @return The final value of iter.
2740 */
2741 static int SearchMapEdge(Point &curr_tile, int &iter, int iter_limit, int offset, int sy_limit, ContinueMapEdgeSearch continue_criteria)
2742 {
2750 }
2752 /**
2753 * Determine the clamping of either the X or Y coordinate to the map.
2754 * @param curr_tile A tile
2755 * @param iter Reference to either the X or Y of curr_tile.
2756 * @param iter_limit Upper search limit for the iter value.
2757 * @param start Start value for the iteration.
2758 * @param other_ref Reference to the opposite axis in curr_tile than of iter.
2759 * @param other_value Start value for of the opposite axis
2760 * @param vp_value Value of the viewport location in the opposite axis as for iter.
2761 * @param other_limit Limit for the other value, so if iter is X, then other_limit is for Y.
2762 * @param vp_top Top of the viewport.
2763 * @param vp_bottom Bottom of the viewport.
2764 * @return Clamped version of vp_value.
2765 */
2766 static inline int ClampXYToMap(Point &curr_tile, int &iter, int iter_limit, int start, int &other_ref, int other_value, int vp_value, int other_limit, int vp_top, int vp_bottom)
2767 {
2770 /*
2771 * First get an estimate of the tiles relevant for us at that edge. Relevant in the sense
2772 * "at least close to the visible area". Thus, we don't look at exactly each tile, inspecting
2773 * e.g. every tenth should be enough. After all, the desired screen limit is set such that
2774 * the bordermost tiles are painted in the middle of the screen when one hits the limit,
2775 * i.e. it is no harm if there is some small error in that calculation
2776 */
2780 int min_iter = SearchMapEdge(curr_tile, iter, iter_limit, upper_edge ? -10 : +10, vp_top, upper_edge ? ContinueLowerMapEdgeSearch : ContinueUpperMapEdgeSearch);
2782 int max_iter = SearchMapEdge(curr_tile, iter, iter_limit, upper_edge ? +10 : -10, vp_bottom, upper_edge ? ContinueUpperMapEdgeSearch : ContinueLowerMapEdgeSearch);
2787 /* Now, calculate the highest heightlevel of these tiles. Again just as an estimate. */
2790 max_heightlevel_at_edge = max(max_heightlevel_at_edge, (int)TileHeight(TileXY(curr_tile.x, curr_tile.y)));
2791 }
2793 /* Based on that heightlevel, calculate the limit. For the upper edge a tile with height zero would
2794 * get a limit of zero, on the other side it depends on the number of tiles along the axis. */
2797 min(vp_value, (other_limit * TILE_SIZE * 4 - max_heightlevel_at_edge * TILE_HEIGHT * 2) * ZOOM_LVL_BASE);
2798 }
2801 {
2804 /* Centre of the viewport is hot spot */
2808 /* Convert viewport coordinates to map coordinates
2809 * Calculation is scaled by 4 to avoid rounding errors */
2813 /* Find out which tile corresponds to (vx,vy) if one assumes height zero. The cast is necessary to prevent C++ from
2814 * converting the result to an uint, which gives an overflow instead of a negative result... */
2818 Point curr_tile;
2819 vx = ClampXYToMap(curr_tile, curr_tile.y, MapMaxY(), ty, curr_tile.x, tx, vx, MapMaxX(), original_y, original_y + vp->virtual_height);
2820 vy = ClampXYToMap(curr_tile, curr_tile.x, MapMaxX(), tx, curr_tile.y, ty, vy, MapMaxY(), original_y, original_y + vp->virtual_height);
2822 /* Convert map coordinates to viewport coordinates */
2826 /* Remove centering */
2829 }
2831 /**
2832 * Update the viewport position being displayed.
2833 * @param w %Window owning the viewport.
2834 */
2836 {
2847 /* Ensure the destination location is within the map */
2857 /* Not at our desired position yet... */
2863 }
2866 }
2884 }
2888 }
2889 }
2891 /**
2892 * Marks a viewport as dirty for repaint if it displays (a part of) the area the needs to be repainted.
2893 * @param vp The viewport to mark as dirty
2894 * @param left Left edge of area to repaint
2895 * @param top Top edge of area to repaint
2896 * @param right Right edge of area to repaint
2897 * @param bottom Bottom edge of area to repaint
2898 * @ingroup dirty
2899 */
2900 static void MarkViewportDirty(const ViewPort * const vp, int left, int top, int right, int bottom)
2901 {
2902 /* Rounding wrt. zoom-out level */
2925 );
2926 }
2928 /**
2929 * Mark all viewports that display an area as dirty (in need of repaint).
2930 * @param left Left edge of area to repaint. (viewport coordinates, that is wrt. #ZOOM_LVL_NORMAL)
2931 * @param top Top edge of area to repaint. (viewport coordinates, that is wrt. #ZOOM_LVL_NORMAL)
2932 * @param right Right edge of area to repaint. (viewport coordinates, that is wrt. #ZOOM_LVL_NORMAL)
2933 * @param bottom Bottom edge of area to repaint. (viewport coordinates, that is wrt. #ZOOM_LVL_NORMAL)
2934 * @param mark_dirty_if_zoomlevel_is_below To tell if an update is relevant or not (for example, animations in map mode are not)
2935 * @ingroup dirty
2936 */
2937 void MarkAllViewportsDirty(int left, int top, int right, int bottom, const ZoomLevel mark_dirty_if_zoomlevel_is_below)
2938 {
2942 }
2943 }
2946 {
2949 }
2952 {
2954 const Point pt = RemapCoords2(TileX(tile) * TILE_SIZE + TILE_SIZE / 2, TileY(tile) * TILE_SIZE + TILE_SIZE / 2);
2958 const int height = ScaleByZoom(_vp_route_step_height_top + char_height * order_nr + _vp_route_step_height_bottom, vp->zoom);
2960 }
2961 }
2964 {
2966 for (RouteStepsMap::const_iterator cit = _vp_route_steps.begin(); cit != _vp_route_steps.end(); cit++) {
2968 }
2971 }
2973 /**
2974 * Mark all viewports in map mode that display an area as dirty (in need of repaint).
2975 * @param left Left edge of area to repaint
2976 * @param top Top edge of area to repaint
2977 * @param right Right edge of area to repaint
2978 * @param bottom Bottom edge of area to repaint
2979 * @ingroup dirty
2980 */
2982 {
2989 }
2990 }
2991 }
2994 {
2999 ZoomLevel zoom = static_cast<ZoomLevel>(Clamp(w->viewport->zoom, _settings_client.gui.zoom_min, _settings_client.gui.zoom_max));
3003 }
3004 }
3005 }
3007 /**
3008 * Mark a tile given by its index dirty for repaint.
3009 * @param tile The tile to mark dirty.
3010 * @param bridge_level_offset Height of bridge on tile to also mark dirty. (Height level relative to north corner.)
3011 * @ingroup dirty
3012 */
3013 void MarkTileDirtyByTile(const TileIndex tile, const ZoomLevel mark_dirty_if_zoomlevel_is_below, int bridge_level_offset)
3014 {
3015 Point pt = RemapCoords(TileX(tile) * TILE_SIZE, TileY(tile) * TILE_SIZE, TilePixelHeight(tile));
3021 mark_dirty_if_zoomlevel_is_below);
3022 }
3024 /**
3025 * Mark a (virtual) tile outside the map dirty for repaint.
3026 * @param x Tile X position.
3027 * @param y Tile Y position.
3028 * @ingroup dirty
3029 */
3031 {
3038 }
3041 {
3045 const Point from_pt = RemapCoords2(TileX(from_tile) * TILE_SIZE + TILE_SIZE / 2, TileY(from_tile) * TILE_SIZE + TILE_SIZE / 2);
3046 const Point to_pt = RemapCoords2(TileX(to_tile) * TILE_SIZE + TILE_SIZE / 2, TileY(to_tile) * TILE_SIZE + TILE_SIZE / 2);
3055 /* http://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm#Simplification */
3067 ZOOM_LVL_END
3068 );
3074 }
3078 }
3079 }
3080 }
3083 {
3084 for (std::vector<DrawnPathRouteTileLine>::const_iterator it = lines.begin(); it != lines.end(); ++it) {
3086 }
3087 }
3090 {
3098 }
3102 }
3106 }
3108 /**
3109 * Mark all tiles in a given bridge by their index dirty for repaint.
3110 * @param tile The start tile of the bridge to mark dirty.
3111 * @param tile The end tile of the bridge to mark dirty.
3112 * @ingroup dirty
3113 */
3115 {
3119 Axis direction;
3124 }
3131 }
3132 }
3135 {
3140 }
3141 }
3143 /**
3144 * Marks the selected tiles as dirty.
3145 *
3146 * This function marks the selected tiles as dirty for repaint
3147 *
3148 * @ingroup dirty
3149 */
3151 {
3164 }
3178 /* make sure everything is multiple of TILE_SIZE */
3181 /* How it works:
3182 * Suppose we have to mark dirty rectangle of 3x4 tiles:
3183 * x
3184 * xxx
3185 * xxxxx
3186 * xxxxx
3187 * xxx
3188 * x
3189 * This algorithm marks dirty columns of tiles, so it is done in 3+4-1 steps:
3190 * 1) x 2) x
3191 * xxx Oxx
3192 * Oxxxx xOxxx
3193 * xxxxx Oxxxx
3194 * xxx xxx
3195 * x x
3196 * And so forth...
3197 */
3205 /* topmost dirty point */
3209 /* bottommost point */
3211 Point bot = RemapCoords(bot_x + TILE_SIZE, bot_y + TILE_SIZE, GetTilePixelZ(bottom_tile)); // bottommost point
3213 /* the 'x' coordinate of 'top' and 'bot' is the same (and always in the same distance from tile middle),
3214 * tile height/slope affects only the 'y' on-screen coordinate! */
3216 int l = top.x - TILE_PIXELS * ZOOM_LVL_BASE; // 'x' coordinate of left side of the dirty rectangle
3218 int r = top.x + TILE_PIXELS * ZOOM_LVL_BASE; // 'x' coordinate of right side of the dirty rectangle
3221 static const int OVERLAY_WIDTH = 4 * ZOOM_LVL_BASE; // part of selection sprites is drawn outside the selected area (in particular: terraforming)
3223 /* For halftile foundations on SLOPE_STEEP_S the sprite extents some more towards the top */
3224 MarkAllViewportsDirty(l - OVERLAY_WIDTH, t - OVERLAY_WIDTH - TILE_HEIGHT * ZOOM_LVL_BASE, r + OVERLAY_WIDTH, b + OVERLAY_WIDTH);
3226 /* haven't we reached the topmost tile yet? */
3231 }
3233 /* the way the bottom tile changes is different when we reach the bottommost tile */
3238 }
3241 /* a_size, b_size describe a rectangle with rotated coordinates */
3254 }
3255 }
3256 }
3257 }
3258 }
3262 {
3265 }
3267 /**
3268 * Test whether a sign is below the mouse
3269 * @param vp the clicked viewport
3270 * @param x X position of click
3271 * @param y Y position of click
3272 * @param sign the sign to check
3273 * @return true if the sign was hit
3274 */
3275 static bool CheckClickOnViewportSign(const ViewPort *vp, int x, int y, const ViewportSign *sign)
3276 {
3278 int sign_half_width = ScaleByZoom((small ? sign->width_small : sign->width_normal) / 2, vp->zoom);
3279 int sign_height = ScaleByZoom(VPSM_TOP + (small ? FONT_HEIGHT_SMALL : FONT_HEIGHT_NORMAL) + VPSM_BOTTOM, vp->zoom);
3286 }
3289 {
3297 }
3298 }
3301 }
3304 {
3305 if (!(HasBit(_display_opt, DO_SHOW_STATION_NAMES) || HasBit(_display_opt, DO_SHOW_WAYPOINT_NAMES)) || IsInvisibilitySet(TO_SIGNS)) return false;
3316 }
3318 }
3319 }
3322 }
3326 {
3327 /* Signs are turned off, or they are transparent and invisibility is ON, or company is a spectator */
3328 if (!HasBit(_display_opt, DO_SHOW_SIGNS) || IsInvisibilitySet(TO_SIGNS) || _local_company == COMPANY_SPECTATOR) return false;
3332 /* If competitor signs are hidden, don't check signs that aren't owned by local company */
3333 if (!HasBit(_display_opt, DO_SHOW_COMPETITOR_SIGNS) && _local_company != si->owner && si->owner != OWNER_DEITY) continue;
3339 }
3340 }
3343 }
3347 {
3355 }
3358 {
3359 Point pt;
3368 }
3375 }
3378 {
3394 }
3395 }
3398 {
3399 /* No click in smallmap mode except for plan making. */
3400 if (vp->zoom >= ZOOM_LVL_DRAW_MAP && !(_thd.place_mode == HT_POINT && _thd.select_proc == DDSP_DRAW_PLANLINE)) return true;
3406 }
3408 /* Vehicle placement mode already handled above. */
3411 /* In polyline mode double-clicking on a single white line, finishes current polyline.
3412 * If however the user double-clicks on a line that has a white and a blue section,
3413 * both lines (white and blue) will be constructed consecutively. */
3418 }
3420 }
3424 }
3440 }
3441 }
3443 }
3445 }
3448 {
3452 TooltipCloseCondition close_cond = (_settings_client.gui.hover_delay_ms == 0) ? TCC_RIGHT_CLICK : TCC_HOVER;
3461 }
3462 }
3465 if (IsInsideMM(tile.x, 0, MapMaxX() * TILE_SIZE) && IsInsideMM(tile.y, 0, MapMaxY() * TILE_SIZE)) {
3468 }
3471 }
3474 {
3480 }
3481 }
3483 /**
3484 * Scrolls the viewport in a window to a given location.
3485 * @param x Desired x location of the map to scroll to (world coordinate).
3486 * @param y Desired y location of the map to scroll to (world coordinate).
3487 * @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.
3488 * @param w %Window containing the viewport.
3489 * @param instant Jump to the location instead of slowly moving to it.
3490 * @return Destination of the viewport was changed (to activate other actions when the viewport is already at the desired position).
3491 */
3493 {
3494 /* The slope cannot be acquired outside of the map, so make sure we are always within the map. */
3501 }
3502 }
3507 if (w->viewport->dest_scrollpos_x == pt.x && w->viewport->dest_scrollpos_y == pt.y) return false;
3513 }
3518 }
3520 /**
3521 * Scrolls the viewport in a window to a given location.
3522 * @param tile Desired tile to center on.
3523 * @param w %Window containing the viewport.
3524 * @param instant Jump to the location instead of slowly moving to it.
3525 * @return Destination of the viewport was changed (to activate other actions when the viewport is already at the desired position).
3526 */
3528 {
3530 }
3532 /**
3533 * Scrolls the viewport of the main window to a given location.
3534 * @param tile Desired tile to center on.
3535 * @param instant Jump to the location instead of slowly moving to it.
3536 * @return Destination of the viewport was changed (to activate other actions when the viewport is already at the desired position).
3537 */
3539 {
3540 return ScrollMainWindowTo(TileX(tile) * TILE_SIZE + TILE_SIZE / 2, TileY(tile) * TILE_SIZE + TILE_SIZE / 2, -1, instant);
3541 }
3543 /**
3544 * Set a tile to display a red error square.
3545 * @param tile Tile that should show the red error square.
3546 */
3548 {
3549 TileIndex old;
3557 }
3558 }
3560 /**
3561 * Highlight \a w by \a h tiles at the cursor.
3562 * @param w Width of the highlighted tiles rectangle.
3563 * @param h Height of the highlighted tiles rectangle.
3564 */
3566 {
3571 }
3574 {
3579 }
3581 /** returns the best autorail highlight type from map coordinates */
3583 {
3585 }
3587 /**
3588 * Reset tile highlighting.
3589 */
3591 {
3596 }
3598 /**
3599 * Is the user dragging a 'diagonal rectangle'?
3600 * @return User is dragging a rotated rectangle.
3601 */
3603 {
3605 }
3607 /**
3608 * Get the window that started the current highlighting.
3609 * @return The window that requested the current tile highlighting, or \c NULL if not available.
3610 */
3612 {
3614 }
3619 {
3620 /* use the 'outersize' to mark the second (blue) part of a polyline selection */
3622 /* get bounds of the second part */
3629 /* include the first part */
3634 /* write new values */
3644 }
3645 }
3647 /**
3648 * Updates tile highlighting for all cases.
3649 * Uses _thd.selstart and _thd.selend and _thd.place_mode (set elsewhere) to determine _thd.pos and _thd.size
3650 * Also drawstyle is determined. Uses _thd.new.* as a buffer and calls SetSelectionTilesDirty() twice,
3651 * Once for the old and once for the new selection.
3652 * _thd is TileHighlightData, found in viewport.h
3653 */
3655 {
3676 }
3684 }
3686 }
3703 /* HT_POLY */
3727 }
3728 }
3730 }
3731 /* HT_RAIL */
3733 /* Draw one highlighted tile in any direction */
3736 }
3737 /* HT_LINE */
3744 new_drawstyle = (pt.x & TILE_UNIT_MASK) + (pt.y & TILE_UNIT_MASK) <= TILE_SIZE ? HT_LINE | HT_DIR_HU : HT_LINE | HT_DIR_HL;
3749 new_drawstyle = (pt.x & TILE_UNIT_MASK) > (pt.y & TILE_UNIT_MASK) ? HT_LINE | HT_DIR_VL : HT_LINE | HT_DIR_VR;
3753 }
3762 }
3765 }
3766 }
3770 /* redraw selection */
3778 /* Clear the old tile selection? */
3789 /* Draw the new tile selection? */
3791 }
3792 }
3794 /**
3795 * Displays the measurement tooltips when selecting multiple tiles
3796 * @param str String to be displayed
3797 * @param close_cond Condition for closing this tooltip.
3798 */
3799 static inline void ShowMeasurementTooltips(StringID str, TooltipCloseCondition close_cond = TCC_LEFT_CLICK)
3800 {
3803 }
3805 /** highlighting tiles while only going over them with the mouse */
3806 void VpStartPlaceSizing(TileIndex tile, ViewportPlaceMethod method, ViewportDragDropSelectionProcess process)
3807 {
3815 /* Needed so several things (road, autoroad, bridges, ...) are placed correctly.
3816 * In effect, placement starts from the centre of a tile
3817 */
3823 }
3836 }
3840 }
3842 }
3845 {
3847 }
3849 /**
3850 * Highlights all tiles between a set of two tiles. Used in dock and tunnel placement
3851 * @param from TileIndex of the first tile to highlight
3852 * @param to TileIndex of the last tile to highlight
3853 */
3855 {
3864 /* show measurement only if there is any length to speak of */
3868 }
3869 }
3872 {
3875 }
3877 /**
3878 * returns information about the 2x1 piece to be build.
3879 * The lower bits (0-3) are the track type.
3880 */
3882 {
3909 }
3910 }
3912 /**
3913 * Check if the direction of start and end tile should be swapped based on
3914 * the dragging-style. Default directions are:
3915 * in the case of a line (HT_RAIL, HT_LINE): DIR_NE, DIR_NW, DIR_N, DIR_E
3916 * in the case of a rect (HT_RECT, HT_POINT): DIR_S, DIR_E
3917 * For example dragging a rectangle area from south to north should be swapped to
3918 * north-south (DIR_S) to obtain the same results with less code. This is what
3919 * the return value signifies.
3920 * @param style HighLightStyle dragging style
3921 * @param start_tile start tile of drag
3922 * @param end_tile end tile of drag
3923 * @return boolean value which when true means start/end should be swapped
3924 */
3926 {
3939 }
3942 }
3944 /**
3945 * Calculates height difference between one tile and another.
3946 * Multiplies the result to suit the standard given by #TILE_HEIGHT_STEP.
3947 *
3948 * To correctly get the height difference we need the direction we are dragging
3949 * in, as well as with what kind of tool we are dragging. For example a horizontal
3950 * autorail tool that starts in bottom and ends at the top of a tile will need the
3951 * maximum of SW, S and SE, N corners respectively. This is handled by the lookup table below
3952 * See #_tileoffs_by_dir in map.cpp for the direction enums if you can't figure out the values yourself.
3953 * @param style Highlighting style of the drag. This includes direction and style (autorail, rect, etc.)
3954 * @param distance Number of tiles dragged, important for horizontal/vertical drags, ignored for others.
3955 * @param start_tile Start tile of the drag operation.
3956 * @param end_tile End tile of the drag operation.
3957 * @return Height difference between two tiles. The tile measurement tool utilizes this value in its tooltip.
3958 */
3959 static int CalcHeightdiff(HighLightStyle style, uint distance, TileIndex start_tile, TileIndex end_tile)
3960 {
3972 };
3974 /* In the case of an area we can determine whether we were dragging south or
3975 * east by checking the X-coordinates of the tiles */
3979 }
3980 FALLTHROUGH;
3989 };
3998 };
4003 /* To handle autorail, we do some magic to be able to use a lookup table.
4004 * Firstly if we drag the other way around, we switch start&end, and if needed
4005 * also flip the drag-position. Eg if it was on the left, and the distance is even
4006 * that means the end, which is now the start is on the right */
4009 /* Use lookup table for start-tile based on HighLightStyle direction */
4013 uint ht = TileHeight(TILE_ADD(start_tile, ToTileIndexDiff(heightdiff_line_by_dir[style_t + 1])));
4016 /* Use lookup table for end-tile based on HighLightStyle direction
4017 * flip around side (lower/upper, left/right) based on distance */
4021 ht = TileHeight(TILE_ADD(end_tile, ToTileIndexDiff(heightdiff_line_by_dir[12 + style_t + 1])));
4024 }
4025 }
4029 }
4031 static void ShowLengthMeasurement(HighLightStyle style, TileIndex start_tile, TileIndex end_tile, TooltipCloseCondition close_cond = TCC_LEFT_CLICK, bool show_single_tile_length = false)
4032 {
4033 static const StringID measure_strings_length[] = {STR_NULL, STR_MEASURE_LENGTH, STR_MEASURE_LENGTH_HEIGHTDIFF};
4041 /* If we are showing a tooltip for horizontal or vertical drags,
4042 * 2 tiles have a length of 1. To bias towards the ceiling we add
4043 * one before division. It feels more natural to count 3 lengths as 2 */
4046 }
4050 }
4053 }
4054 }
4056 /**
4057 * Check for underflowing the map.
4058 * @param test the variable to test for underflowing
4059 * @param other the other variable to update to keep the line
4060 * @param mult the constant to multiply the difference by for \c other
4061 */
4063 {
4068 }
4070 /**
4071 * Check for overflowing the map.
4072 * @param test the variable to test for overflowing
4073 * @param other the other variable to update to keep the line
4074 * @param max the maximum value for the \c test variable
4075 * @param mult the constant to multiply the difference by for \c other
4076 */
4078 {
4083 }
4091 {
4092 Trackdir ret;
4105 }
4106 }
4109 }
4112 {
4113 /* relative coordinats of the mouse point (offset against the snap point) */
4119 /* in-tile alignment of the snap point (there are two variants: [0, 8] or [8, 0]) */
4122 assert((align_x == TILE_SIZE / 2 && align_y == 0 && !(start.dirs & X_DIRS)) || (align_x == 0 && align_y == TILE_SIZE / 2 && !(start.dirs & Y_DIRS)));
4124 /* absolute distance between points (in tiles) */
4130 /* Find on which quadrant is the mouse point (reltively to the snap point).
4131 * Numeration (clockwise like in Direction):
4132 * ortho diag
4133 * \ 2 / 2 | 3
4134 * \ / --+---> [we]
4135 * 1 X 3 1 | 0
4136 * / \ v
4137 * [x] 0 [y] [ns] */
4141 /* direction from the snap point to the mouse point */
4142 Direction ortho_line_dir = ChangeDir(DIR_S, (DirDiff)(2 * ortho_quadrant)); // DIR_S is the middle of the ortho quadrant no. 0
4143 Direction diag_line_dir = ChangeDir(DIR_SE, (DirDiff)(2 * diag_quadrant)); // DIR_SE is the middle of the diag quadrant no. 0
4146 /* length of booth segments of auto line (choosing orthogonal direction first) */
4153 ortho_len++;
4156 }
4157 }
4159 /* length of booth segments of auto line (choosing diagonal direction first) */
4167 }
4168 }
4170 /* choose the best variant */
4172 /* in the first place, choose this line whose first segment ends up closer
4173 * to the mouse point (thus the second segment is shorter) */
4175 /* if equeal, choose the shorter line */
4177 /* finally look at small "units" and choose the line which is closer to the mouse point */
4179 /* based on comparison, disable one of variants */
4184 }
4185 }
4187 /* store results */
4200 }
4204 }
4206 /**
4207 * Calculate squared euclidean distance between two points.
4208 * @param a the first point
4209 * @param b the second point
4210 * @return |b - a| ^ 2
4211 */
4213 {
4215 }
4217 static LineSnapPoint *FindBestPolyline(const Point &pt, LineSnapPoint *snap_points, uint num_points, Polyline *ret)
4218 {
4219 /* Find the best polyline (a pair of two lines - the white one and the blue
4220 * one) led from any of saved snap points to the mouse cursor. */
4222 LineSnapPoint *best_snap_point = NULL; // the best polyline we found so far is led from this snap point
4225 /* try to fit a polyline */
4226 Polyline polyline;
4228 /* check whether we've found a better polyline */
4230 /* firstly choose shorter polyline (the one with smaller amount of
4231 * track pieces composing booth the white and the blue line) */
4235 /* secondly choose that polyline which has longer first (white) line */
4237 /* finally check euclidean distance to snap points and choose the
4238 * one which is closer */
4239 if (cur_len == best_len && polyline.first_len == ret->first_len && SqrDist(pt, snap_points[i]) >= SqrDist(pt, *best_snap_point)) continue;
4240 }
4241 /* save the found polyline */
4244 }
4247 }
4249 /** while dragging */
4251 {
4252 HighLightStyle b;
4260 /* We 'force' a selection direction; first four rail buttons. */
4277 /* We are on a straight horizontal line. Determine the 'rail'
4278 * to build based the sub tile location. */
4279 b = (x & TILE_UNIT_MASK) + (y & TILE_UNIT_MASK) >= TILE_SIZE ? HT_LINE | HT_DIR_HL : HT_LINE | HT_DIR_HU;
4281 /* We are not on a straight line. Determine the rail to build
4282 * based on whether we are above or below it. */
4285 /* Calculate where a horizontal line through the start point and
4286 * a vertical line from the selected end point intersect and
4287 * use that point as the end point. */
4292 /* 'Build' the last half rail tile if needed */
4298 }
4299 }
4301 /* Make sure we do not overflow the map! */
4306 assert(x >= 0 && y >= 0 && x <= (int)(MapMaxX() * TILE_SIZE) && y <= (int)(MapMaxY() * TILE_SIZE));
4307 }
4312 /* We are on a straight vertical line. Determine the 'rail'
4313 * to build based the sub tile location. */
4316 /* We are not on a straight line. Determine the rail to build
4317 * based on whether we are left or right from it. */
4320 /* Calculate where a vertical line through the start point and
4321 * a horizontal line from the selected end point intersect and
4322 * use that point as the end point. */
4327 /* 'Build' the last half rail tile if needed */
4333 }
4334 }
4336 /* Make sure we do not overflow the map! */
4341 assert(x >= 0 && y >= 0 && x <= (int)(MapMaxX() * TILE_SIZE) && y <= (int)(MapMaxY() * TILE_SIZE));
4342 }
4347 }
4348 } else if (TileVirtXY(_thd.selstart.x, _thd.selstart.y) == TileVirtXY(x, y)) { // check if we're only within one tile
4353 }
4361 }
4370 }
4383 /* four cases. */
4386 /* south */
4395 }
4397 /* west */
4399 b = (x & TILE_UNIT_MASK) + (y & TILE_UNIT_MASK) >= TILE_SIZE ? HT_LINE | HT_DIR_HL : HT_LINE | HT_DIR_HU;
4406 }
4407 }
4410 /* east */
4412 b = (x & TILE_UNIT_MASK) + (y & TILE_UNIT_MASK) >= TILE_SIZE ? HT_LINE | HT_DIR_HL : HT_LINE | HT_DIR_HU;
4419 }
4421 /* north */
4430 }
4431 }
4432 }
4433 }
4440 ShowLengthMeasurement(b, TileVirtXY(_thd.selstart.x, _thd.selstart.y), TileVirtXY(_thd.selend.x, _thd.selend.y));
4441 }
4444 {
4447 /* are we only within one tile? */
4452 }
4454 /* find the best track */
4455 Polyline line;
4464 snap_point = FindBestPolyline(pt, _tile_snap_points.Begin(), _tile_snap_points.Length(), &line);
4467 snap_point = FindBestPolyline(pt, _rail_snap_points.Begin(), _rail_snap_points.Length(), &line);
4468 }
4473 /* lock down the snap point */
4476 }
4481 _thd.selend.x = _thd.selstart.x + line.first_len * first_dir.x * (IsDiagonalDirection(line.first_dir) ? TILE_SIZE : TILE_SIZE / 2);
4482 _thd.selend.y = _thd.selstart.y + line.first_len * first_dir.y * (IsDiagonalDirection(line.first_dir) ? TILE_SIZE : TILE_SIZE / 2);
4495 _thd.selend2.x = _thd.selstart2.x + line.second_len * second_dir.x * (IsDiagonalDirection(line.second_dir) ? TILE_SIZE : TILE_SIZE / 2);
4496 _thd.selend2.y = _thd.selstart2.y + line.second_len * second_dir.y * (IsDiagonalDirection(line.second_dir) ? TILE_SIZE : TILE_SIZE / 2);
4507 }
4510 ShowLengthMeasurement(ret, TileVirtXY(_thd.selstart.x, _thd.selstart.y), TileVirtXY(_thd.selend.x, _thd.selend.y), TCC_HOVER, true);
4512 }
4514 /**
4515 * Selects tiles while dragging
4516 * @param x X coordinate of end of selection
4517 * @param y Y coordinate of end of selection
4518 * @param method modifies the way tiles are selected. Possible
4519 * methods are VPM_* in viewport.h
4520 */
4522 {
4524 HighLightStyle style;
4529 }
4535 }
4537 /* Special handling of drag in any (8-way) direction */
4543 }
4545 /* Needed so level-land is placed correctly */
4549 }
4564 }
4569 FALLTHROUGH;
4578 FALLTHROUGH;
4584 calc_heightdiff_single_direction:;
4588 }
4589 /* With current code passing a HT_LINE style to calculate the height
4590 * difference is enough. However if/when a point-tool is created
4591 * with this method, function should be called with new_style (below)
4592 * instead of HT_LINE | style case HT_POINT is handled specially
4593 * new_style := (_thd.next_drawstyle & HT_RECT) ? HT_LINE | style : _thd.next_drawstyle; */
4604 /* If dragging an area (eg dynamite tool) and it is actually a single
4605 * row/column, change the type to 'line' to get proper calculation for height */
4612 }
4613 }
4624 }
4629 //Show always the measurement tooltip
4632 }
4638 FALLTHROUGH;
4644 };
4652 /* If dragging an area (eg dynamite tool) and it is actually a single
4653 * row/column, change the type to 'line' to get proper calculation for height */
4656 /* Determine the "area" of the diagonal dragged selection.
4657 * We assume the area is the number of tiles along the X
4658 * edge and the number of tiles along the Y edge. However,
4659 * multiplying these two numbers does not give the exact
4660 * number of tiles; basically we are counting the black
4661 * squares on a chess board and ignore the white ones to
4662 * make the tile counts at the edges match up. There is no
4663 * other way to make a proper count though.
4664 *
4665 * First convert to the rotated coordinate system. */
4671 /* Now determine the size along the edge, but due to the
4672 * chess board principle this counts double. */
4676 /* We get a 1x1 on normal 2x1 rectangles, due to it being
4677 * a seen as two sides. As the result for actual building
4678 * will be the same as non-diagonal dragging revert to that
4679 * behaviour to give it a more normally looking size. */
4683 }
4689 }
4690 }
4698 }
4701 }
4705 }
4710 }
4712 /**
4713 * Handle the mouse while dragging for placement/resizing.
4714 * @return State of handling the event.
4715 */
4717 {
4720 /* stop drag mode if the window has been closed */
4725 }
4727 /* While dragging execute the drag procedure of the corresponding window (mostly VpSelectTilesWithMethod() ).
4728 * Do it even if the button is no longer pressed to make sure that OnPlaceDrag was called at least once. */
4732 /* mouse button released..
4733 * keep the selected tool, but reset it to the original mode. */
4741 _thd.place_mode = (_thd.select_method & ~VPM_RAILDIRS ? _thd.next_drawstyle : HT_RAIL) | others;
4744 }
4750 }
4752 w->OnPlaceMouseUp(_thd.select_method, _thd.select_proc, _thd.selend, TileVirtXY(_thd.selstart.x, _thd.selstart.y), TileVirtXY(_thd.selend.x, _thd.selend.y));
4754 }
4756 /**
4757 * Change the cursor and mouse click/drag handling to a mode for performing special operations like tile area selection, object placement, etc.
4758 * @param icon New shape of the mouse cursor.
4759 * @param pal Palette to use.
4760 * @param mode Mode to perform.
4761 * @param w %Window requesting the mode change.
4762 */
4764 {
4766 }
4770 /**
4771 * Change the cursor and mouse click/drag handling to a mode for performing special operations like tile area selection, object placement, etc.
4772 * @param icon New shape of the mouse cursor.
4773 * @param pal Palette to use.
4774 * @param mode Mode to perform.
4775 * @param window_class %Window class of the window requesting the mode change.
4776 * @param window_num Number of the window in its class requesting the mode change.
4777 */
4778 void SetObjectToPlace(CursorID icon, PaletteID pal, HighLightStyle mode, WindowClass window_class, WindowNumber window_num)
4779 {
4781 /* Undo clicking on button and drag & drop */
4783 /* Call the abort function, but set the window class to something
4784 * that will never be used to avoid infinite loops. Setting it to
4785 * the 'next' window class must not be done because recursion into
4786 * this function might in some cases reset the newly set object to
4787 * place or not properly reset the original selection. */
4790 }
4792 /* Mark the old selection dirty, in case the selection shape or colour changes */
4804 }
4810 if ((mode & HT_DRAG_MASK) == HT_SPECIAL) { // special tools, like tunnels or docks start with presizing mode
4812 }
4816 }
4822 }
4824 }
4826 /** Reset the cursor and mouse mode handling back to default (normal cursor, only clicking in windows). */
4828 {
4830 }
4839 }
4840 }
4843 {
4846 int z = GetSlopePixelZ(Clamp(x, 0, MapSizeX() * TILE_SIZE - 1), Clamp(y, 0, MapSizeY() * TILE_SIZE - 1));
4852 }
4855 {
4862 }
4863 }
4865 /** Helper class for getting the best sprite sorter. */
4869 };
4871 /** List of sorters ordered from best to worst. */
4873 #ifdef WITH_SSE
4875 #endif
4877 };
4879 /** Choose the "best" sprite sorter and set _vp_sprite_sorter. */
4881 {
4886 }
4887 }
4889 }
4891 static LineSnapPoint LineSnapPointAtRailTrackEndpoint(TileIndex tile, DiagDirection exit_dir, bool bidirectional)
4892 {
4893 LineSnapPoint ret;
4904 }
4906 /**
4907 * Store the position of lastly built rail track; for highlighting purposes.
4908 *
4909 * In "polyline" highlighting mode, the stored end point will be used as a snapping point for new
4910 * tracks allowing to place multi-segment polylines.
4911 *
4912 * @param start_tile tile where the track starts
4913 * @param end_tile tile where the track ends
4914 * @param start_track track piece on the start_tile
4915 * @param bidirectional_exit whether to allow to highlight next track in any direction; otherwise new track will have to fallow the stored one (usefull when placing tunnels and bridges)
4916 */
4917 void StoreRailPlacementEndpoints(TileIndex start_tile, TileIndex end_tile, Track start_track, bool bidirectional_exit)
4918 {
4920 /* calculate trackdirs at booth ends of the track */
4924 /* determine proper direction (pointing outside of the track) */
4926 if (distance > DistanceManhattan(TileAddByDiagDir(start_tile, TrackdirToExitdir(exit_trackdir_at_start)), end_tile)) {
4928 }
4929 /* determine proper track on the end tile - switch between upper/lower or left/right based on the length */
4931 }
4933 LineSnapPoint snap_start = LineSnapPointAtRailTrackEndpoint(start_tile, TrackdirToExitdir(exit_trackdir_at_start), bidirectional_exit);
4934 LineSnapPoint snap_end = LineSnapPointAtRailTrackEndpoint(end_tile, TrackdirToExitdir(exit_trackdir_at_end), bidirectional_exit);
4935 /* Find if we already had these coordinates before. */
4942 }
4943 /* Create new snap point set. */
4945 /* just stop snaping, don't forget snap points */
4948 /* include only new points */
4953 }
4954 }
4955 }
4958 {
4960 }
4963 {
4964 if (_rail_snap_mode == RSM_SNAP_TO_TILE && _tile_snap_points.Length() == 0) return RSM_NO_SNAP;
4965 if (_rail_snap_mode == RSM_SNAP_TO_RAIL && _rail_snap_points.Length() == 0) return RSM_NO_SNAP;
4967 }
4970 {
4975 }
4976 }
4979 {
4982 }
4985 {
4993 }
4994 }
4997 {
5002 }