openttd-ottdgrfs: comparison src/viewport.cpp

equal deleted inserted replaced

-:ca3fd1fbe311
+:5a9dc001e1ad
 #include "train.h"
 #include "roadveh.h"
 #include "vehicle_gui.h"
 #include "blitter/factory.hpp"
 #include "newgrf_fsmports.h"
+#include "transparency.h"
 #define VIEWPORT_DRAW_MEM (65536 * 2)
 ZoomLevel _saved_scrollpos_zoom;
 /* XXX - maximum viewports is maximum windows - 2 (main toolbar + status bar) */
 static ViewPort _viewports[25 - 2];
 static uint32 _active_viewports;    ///< bitmasked variable where each bit signifies if a viewport is in use or not
 assert_compile(lengthof(_viewports) < sizeof(_active_viewports) * 8);
-static bool _added_tile_sprite;
-static bool _offset_ground_sprites;
 /* The in-game coordiante system looks like this *
 *                                               *
 *                    ^ Z                        *
 *                    |                          *
 assert_compile(sizeof(LARGEST_SPRITELIST_STRUCT) >= sizeof(StringSpriteToDraw));
 assert_compile(sizeof(LARGEST_SPRITELIST_STRUCT) >= sizeof(TileSpriteToDraw));
 assert_compile(sizeof(LARGEST_SPRITELIST_STRUCT) >= sizeof(ChildScreenSpriteToDraw));
 assert_compile(sizeof(LARGEST_SPRITELIST_STRUCT) >= sizeof(ParentSpriteToDraw));
+/* Enumeration of multi-part foundations */
+enum FoundationPart {
+	FOUNDATION_PART_NONE     = 0xFF,  ///< Neither foundation nor groundsprite drawn yet.
+	FOUNDATION_PART_NORMAL   = 0,     ///< First part (normal foundation or no foundation)
+	FOUNDATION_PART_HALFTILE = 1,     ///< Second part (halftile foundation)
+	FOUNDATION_PART_END
+};
 struct ViewportDrawer {
 	DrawPixelInfo dpi;
 	byte *spritelist_mem;
 	const byte *eof_spritelist_mem;
 	ParentSpriteToDraw **parent_list;
 	ParentSpriteToDraw * const *eof_parent_list;
 	byte combine_sprites;
-	int offs_x, offs_y; // used when drawing ground sprites relative
+	ParentSpriteToDraw *foundation[FOUNDATION_PART_END];                   ///< Foundation sprites.
+	FoundationPart foundation_part;                                        ///< Currently active foundation for ground sprite drawing.
+	ChildScreenSpriteToDraw **last_foundation_child[FOUNDATION_PART_END];  ///< Tail of ChildSprite list of the foundations.
+	Point foundation_offset[FOUNDATION_PART_END];                          ///< Pixeloffset for ground sprites on the foundations.
 };
 static ViewportDrawer *_cur_vd;
 TileHighlightData _thd;
 	_active_viewports = 0;
 }
 void DeleteWindowViewport(Window *w)
 {
-	CLRBIT(_active_viewports, w->viewport - _viewports);
+	ClrBit(_active_viewports, w->viewport - _viewports);
 	w->viewport->width = 0;
 	w->viewport = NULL;
 }
 void AssignWindowViewport(Window *w, int x, int y,
 	for (vp = _viewports, bit = 0; ; vp++, bit++) {
 		assert(vp != endof(_viewports));
 		if (vp->width == 0) break;
 	}
-	SETBIT(_active_viewports, bit);
+	SetBit(_active_viewports, bit);
 	vp->left = x + w->left;
 	vp->top = y + w->top;
 	vp->width = width;
 	vp->height = height;
 	int left, top, width, height;
 	vp->virtual_left = x;
 	vp->virtual_top = y;
-	old_left = UnScaleByZoom(old_left, vp->zoom);
+	/* viewport is bound to its left top corner, so it must be rounded down (UnScaleByZoomLower)
-	old_top = UnScaleByZoom(old_top, vp->zoom);
+	 * else glitch described in FS#1412 will happen (offset by 1 pixel with zoom level > NORMAL)
-	x = UnScaleByZoom(x, vp->zoom);
+	 */
-	y = UnScaleByZoom(y, vp->zoom);
+	old_left = UnScaleByZoomLower(old_left, vp->zoom);
+	old_top = UnScaleByZoomLower(old_top, vp->zoom);
+	x = UnScaleByZoomLower(x, vp->zoom);
+	y = UnScaleByZoomLower(y, vp->zoom);
 	old_left -= x;
 	old_top -= y;
 	if (old_top == 0 && old_left == 0) return;
 ViewPort *IsPtInWindowViewport(const Window *w, int x, int y)
 {
 	ViewPort *vp = w->viewport;
 	if (vp != NULL &&
-	    IS_INT_INSIDE(x, vp->left, vp->left + vp->width) &&
+	    IsInsideMM(x, vp->left, vp->left + vp->width) &&
-			IS_INT_INSIDE(y, vp->top, vp->top + vp->height))
+			IsInsideMM(y, vp->top, vp->top + vp->height))
 		return vp;
 	return NULL;
 }
 	b = y+x;
 	/* we need to move variables in to the valid range, as the
 	 * GetTileZoomCenterWindow() function can call here with invalid x and/or y,
 	 * when the user tries to zoom out along the sides of the map */
-	a = clamp(a, 0, (int)(MapMaxX() * TILE_SIZE) - 1);
+	a = Clamp(a, 0, (int)(MapMaxX() * TILE_SIZE) - 1);
-	b = clamp(b, 0, (int)(MapMaxY() * TILE_SIZE) - 1);
+	b = Clamp(b, 0, (int)(MapMaxY() * TILE_SIZE) - 1);
-	z = GetSlopeZ(a,     b    ) / 2;
+	/* (a, b) is the X/Y-world coordinate that belongs to (x,y) if the landscape would be completely flat on height 0.
-	z = GetSlopeZ(a + z, b + z) / 2;
+	 * Now find the Z-world coordinate by fix point iteration.
-	z = GetSlopeZ(a + z, b + z) / 2;
+	 * This is a bit tricky because the tile height is non-continuous at foundations.
-	z = GetSlopeZ(a + z, b + z) / 2;
+	 * The clicked point should be approached from the back, otherwise there are regions that are not clickable.
-	z = GetSlopeZ(a + z, b + z) / 2;
+	 * (FOUNDATION_HALFTILE_LOWER on SLOPE_STEEP_S hides north halftile completely)
+	 * So give it a z-malus of 4 in the first iterations.
+	 */
+	z = 0;
+	for (int i = 0; i < 5; i++) z = GetSlopeZ(a + max(z, 4u) - 4, b + max(z, 4u) - 4) / 2;
+	for (uint malus = 3; malus > 0; malus--) z = GetSlopeZ(a + max(z, malus) - malus, b + max(z, malus) - malus) / 2;
+	for (int i = 0; i < 5; i++) z = GetSlopeZ(a + z, b + z) / 2;
 	pt.x = a + z;
 	pt.y = b + z;
 	return pt;
 * @param vp pointer to the viewport whose zoom-level the buttons represent
 * @param widget_zoom_in widget index for window with zoom-in button
 * @param widget_zoom_out widget index for window with zoom-out button */
 void HandleZoomMessage(Window *w, const ViewPort *vp, byte widget_zoom_in, byte widget_zoom_out)
 {
-	SetWindowWidgetDisabledState(w, widget_zoom_in, vp->zoom == ZOOM_LVL_MIN);
+	w->SetWidgetDisabledState(widget_zoom_in, vp->zoom == ZOOM_LVL_MIN);
 	InvalidateWidget(w, widget_zoom_in);
-	SetWindowWidgetDisabledState(w, widget_zoom_out, vp->zoom == ZOOM_LVL_MAX);
+	w->SetWidgetDisabledState(widget_zoom_out, vp->zoom == ZOOM_LVL_MAX);
 	InvalidateWidget(w, widget_zoom_out);
 }
 /**
 * Draws a ground sprite at a specific world-coordinate.
 	*vd->last_tile = ts;
 	vd->last_tile = &ts->next;
 }
 /**
+* Adds a child sprite to the active foundation.
+*
+* The pixel offset of the sprite relative to the ParentSprite is the sum of the offset passed to OffsetGroundSprite() and extra_offs_?.
+*
+* @param image the image to draw.
+* @param pal the provided palette.
+* @param sub Only draw a part of the sprite.
+* @param foundation_part Foundation part.
+* @param extra_offs_x Pixel X offset for the sprite position.
+* @param extra_offs_y Pixel Y offset for the sprite position.
+*/
+static void AddChildSpriteToFoundation(SpriteID image, SpriteID pal, const SubSprite *sub, FoundationPart foundation_part, int extra_offs_x, int extra_offs_y)
+{
+	ViewportDrawer *vd = _cur_vd;
+	assert(IsInsideMM(foundation_part, 0, FOUNDATION_PART_END));
+	assert(vd->foundation[foundation_part] != NULL);
+	Point offs = vd->foundation_offset[foundation_part];
+	/* Change the active ChildSprite list to the one of the foundation */
+	ChildScreenSpriteToDraw **old_child = vd->last_child;
+	vd->last_child = vd->last_foundation_child[foundation_part];
+	AddChildSpriteScreen(image, pal, offs.x + extra_offs_x, offs.y + extra_offs_y, false, sub);
+	/* Switch back to last ChildSprite list */
+	vd->last_child = old_child;
+}
+/**
 * Draws a ground sprite for the current tile.
 * If the current tile is drawn on top of a foundation the sprite is added as child sprite to the "foundation"-ParentSprite.
 *
 * @param image the image to draw.
 * @param pal the provided palette.
 * @param sub Only draw a part of the sprite.
 */
 void DrawGroundSprite(SpriteID image, SpriteID pal, const SubSprite *sub)
 {
-	if (_offset_ground_sprites) {
+	ViewportDrawer *vd = _cur_vd;
-		/* offset ground sprite because of foundation? */
+	/* Switch to first foundation part, if no foundation was drawn */
-		AddChildSpriteScreen(image, pal, _cur_vd->offs_x, _cur_vd->offs_y, false, sub);
+	if (vd->foundation_part == FOUNDATION_PART_NONE) vd->foundation_part = FOUNDATION_PART_NORMAL;
+	if (vd->foundation[vd->foundation_part] != NULL) {
+		AddChildSpriteToFoundation(image, pal, sub, vd->foundation_part, 0, 0);
 	} else {
-		_added_tile_sprite = true;
 		DrawGroundSpriteAt(image, pal, _cur_ti->x, _cur_ti->y, _cur_ti->z, sub);
 	}
 }
+/**
+* Called when a foundation has been drawn for the current tile.
+* Successive ground sprites for the current tile will be drawn as child sprites of the "foundation"-ParentSprite, not as TileSprites.
+*
+* @param x sprite x-offset (screen coordinates) of ground sprites relative to the "foundation"-ParentSprite.
+* @param y sprite y-offset (screen coordinates) of ground sprites relative to the "foundation"-ParentSprite.
+*/
 void OffsetGroundSprite(int x, int y)
 {
-	_cur_vd->offs_x = x;
+	ViewportDrawer *vd = _cur_vd;
-	_cur_vd->offs_y = y;
+	/* Switch to next foundation part */
-	_offset_ground_sprites = true;
+	switch (vd->foundation_part) {
+		case FOUNDATION_PART_NONE:
+			vd->foundation_part = FOUNDATION_PART_NORMAL;
+			break;
+		case FOUNDATION_PART_NORMAL:
+			vd->foundation_part = FOUNDATION_PART_HALFTILE;
+			break;
+		default: NOT_REACHED();
+	}
+	/* vd->last_child == NULL if foundation sprite was clipped by the viewport bounds */
+	if (vd->last_child != NULL) vd->foundation[vd->foundation_part] = vd->parent_list[-1];
+	vd->foundation_offset[vd->foundation_part].x = x;
+	vd->foundation_offset[vd->foundation_part].y = y;
+	vd->last_foundation_child[vd->foundation_part] = vd->last_child;
 }
 /**
 * Adds a child sprite to a parent sprite.
 * In contrast to "AddChildSpriteScreen()" the sprite position is in world coordinates
 	assert((image & SPRITE_MASK) < MAX_SPRITES);
 	/* make the sprites transparent with the right palette */
 	if (transparent) {
-		SETBIT(image, PALETTE_MODIFIER_TRANSPARENT);
+		SetBit(image, PALETTE_MODIFIER_TRANSPARENT);
 		pal = PALETTE_TO_TRANSPARENT;
 	}
 	if (vd->combine_sprites == 2) {
 		AddCombinedSprite(image, pal, x, y, z, sub);
 	assert((image & SPRITE_MASK) < MAX_SPRITES);
 	/* make the sprites transparent with the right palette */
 	if (transparent) {
-		SETBIT(image, PALETTE_MODIFIER_TRANSPARENT);
+		SetBit(image, PALETTE_MODIFIER_TRANSPARENT);
 		pal = PALETTE_TO_TRANSPARENT;
 	}
 	if (vd->spritelist_mem >= vd->eof_spritelist_mem) {
 		DEBUG(sprite, 0, "Out of sprite memory");
 	/* If the ParentSprite was clipped by the viewport bounds, do not draw the ChildSprites either */
 	if (vd->last_child == NULL) return;
 	vd->spritelist_mem += sizeof(ChildScreenSpriteToDraw);
+	/* Append the sprite to the active ChildSprite list.
+	 * If the active ParentSprite is a foundation, update last_foundation_child as well. */
 	*vd->last_child = cs;
+	if (vd->last_foundation_child[0] == vd->last_child) vd->last_foundation_child[0] = &cs->next;
+	if (vd->last_foundation_child[1] == vd->last_child) vd->last_foundation_child[1] = &cs->next;
 	vd->last_child = &cs->next;
 	cs->image = image;
 	cs->pal = pal;
 	cs->sub = sub;
 	return ss;
 }
-static void DrawSelectionSprite(SpriteID image, SpriteID pal, const TileInfo *ti)
+/**
-{
+* Draws sprites between ground sprite and everything above.
-	if (_added_tile_sprite && !(_thd.drawstyle & HT_LINE)) { // draw on real ground
+*
-		DrawGroundSpriteAt(image, pal, ti->x, ti->y, ti->z + 7);
+* The sprite is either drawn as TileSprite or as ChildSprite of the active foundation.
-	} else { // draw on top of foundation
+*
-		AddSortableSpriteToDraw(image, pal, ti->x, ti->y, 0x10, 0x10, 1, ti->z + 7);
+* @param image the image to draw.
+* @param pal the provided palette.
+* @param ti TileInfo Tile that is being drawn
+* @param z_offset Z offset relative to the groundsprite. Only used for the sprite position, not for sprite sorting.
+* @param foundation_part Foundation part the sprite belongs to.
+*/
+static void DrawSelectionSprite(SpriteID image, SpriteID pal, const TileInfo *ti, int z_offset, FoundationPart foundation_part)
+{
+	/* FIXME: This is not totally valid for some autorail highlights, that extent over the edges of the tile. */
+	if (_cur_vd->foundation[foundation_part] == NULL) {
+		/* draw on real ground */
+		DrawGroundSpriteAt(image, pal, ti->x, ti->y, ti->z + z_offset);
+	} else {
+		/* draw on top of foundation */
+		AddChildSpriteToFoundation(image, pal, NULL, foundation_part, 0, -z_offset);
 	}
 }
 /**
 * Draws a selection rectangle on a tile.
 * @param ti TileInfo Tile that is being drawn
 * @param pal Palette to apply.
 */
 static void DrawTileSelectionRect(const TileInfo *ti, SpriteID pal)
 {
-	DrawSelectionSprite(SPR_SELECT_TILE + _tileh_to_sprite[ti->tileh], pal, ti);
+	SpriteID sel;
+	if (IsHalftileSlope(ti->tileh)) {
+		Corner halftile_corner = GetHalftileSlopeCorner(ti->tileh);
+		SpriteID sel2 = SPR_HALFTILE_SELECTION_FLAT + halftile_corner;
+		DrawSelectionSprite(sel2, pal, ti, 7 + TILE_HEIGHT, FOUNDATION_PART_HALFTILE);
+		Corner opposite_corner = OppositeCorner(halftile_corner);
+		if (IsSteepSlope(ti->tileh)) {
+			sel = SPR_HALFTILE_SELECTION_DOWN;
+		} else {
+			sel = ((ti->tileh & SlopeWithOneCornerRaised(opposite_corner)) != 0 ? SPR_HALFTILE_SELECTION_UP : SPR_HALFTILE_SELECTION_FLAT);
+		}
+		sel += opposite_corner;
+	} else {
+		sel = SPR_SELECT_TILE + _tileh_to_sprite[ti->tileh];
+	}
+	DrawSelectionSprite(sel, pal, ti, 7, FOUNDATION_PART_NORMAL);
 }
 static bool IsPartOfAutoLine(int px, int py)
 {
 	px -= _thd.selstart.x;
 {
 	SpriteID image;
 	SpriteID pal;
 	int offset;
-	offset = _AutorailTilehSprite[ti->tileh][autorail_type];
+	FoundationPart foundation_part = FOUNDATION_PART_NORMAL;
+	Slope autorail_tileh = (Slope)(ti->tileh & ~SLOPE_HALFTILE_MASK);
+	if (IsHalftileSlope(ti->tileh)) {
+		static const uint _lower_rail[4] = { 5U, 2U, 4U, 3U };
+		Corner halftile_corner = GetHalftileSlopeCorner(ti->tileh);
+		if (autorail_type != _lower_rail[halftile_corner]) {
+			foundation_part = FOUNDATION_PART_HALFTILE;
+			/* Here we draw the highlights of the "three-corners-raised"-slope. That looks ok to me. */
+			autorail_tileh = SlopeWithThreeCornersRaised(OppositeCorner(halftile_corner));
+		}
+	}
+	offset = _AutorailTilehSprite[autorail_tileh][autorail_type];
 	if (offset >= 0) {
 		image = SPR_AUTORAIL_BASE + offset;
 		pal = PAL_NONE;
 	} else {
 		image = SPR_AUTORAIL_BASE - offset;
 		pal = PALETTE_SEL_TILE_RED;
 	}
-	DrawSelectionSprite(image, _thd.make_square_red ? PALETTE_SEL_TILE_RED : pal, ti);
+	DrawSelectionSprite(image, _thd.make_square_red ? PALETTE_SEL_TILE_RED : pal, ti, 7, foundation_part);
 }
 /**
 * Checks if the specified tile is selected and if so draws selection using correct selectionstyle.
 * @param *ti TileInfo Tile that is being drawn
 	/* no selection active? */
 	if (_thd.drawstyle == 0) return;
 	/* Inside the inner area? */
-	if (IS_INSIDE_1D(ti->x, _thd.pos.x, _thd.size.x) &&
+	if (IsInsideBS(ti->x, _thd.pos.x, _thd.size.x) &&
-			IS_INSIDE_1D(ti->y, _thd.pos.y, _thd.size.y)) {
+			IsInsideBS(ti->y, _thd.pos.y, _thd.size.y)) {
 		if (_thd.drawstyle & HT_RECT) {
 			if (_thd.FSMportLayout != NULL) {
 				byte *b = *_thd.FSMportLayout;
 				byte *m;
 				if (_thd.FSMportMask != NULL) m = *_thd.FSMportMask;
 			if (_thd.FSMportLayout == NULL) {
 				DrawTileSelectionRect(ti, _thd.make_square_red ? PALETTE_SEL_TILE_RED : PAL_NONE);
 			}
 		} else if (_thd.drawstyle & HT_POINT) {
 			/* Figure out the Z coordinate for the single dot. */
-			byte z = ti->z;
+			byte z = 0;
+			FoundationPart foundation_part = FOUNDATION_PART_NORMAL;
 			if (ti->tileh & SLOPE_N) {
 				z += TILE_HEIGHT;
-				if (ti->tileh == SLOPE_STEEP_N) z += TILE_HEIGHT;
+				if ((ti->tileh & ~SLOPE_HALFTILE_MASK) == SLOPE_STEEP_N) z += TILE_HEIGHT;
 			}
-			DrawGroundSpriteAt(_cur_dpi->zoom <= ZOOM_LVL_DETAIL ? SPR_DOT : SPR_DOT_SMALL, PAL_NONE, ti->x, ti->y, z);
+			if (IsHalftileSlope(ti->tileh)) {
+				Corner halftile_corner = GetHalftileSlopeCorner(ti->tileh);
+				if ((halftile_corner == CORNER_W) || (halftile_corner == CORNER_E)) z += TILE_HEIGHT;
+				if (halftile_corner != CORNER_S) {
+					foundation_part = FOUNDATION_PART_HALFTILE;
+					if (IsSteepSlope(ti->tileh)) z -= TILE_HEIGHT;
+				}
+			}
+			DrawSelectionSprite(_cur_dpi->zoom <= ZOOM_LVL_DETAIL ? SPR_DOT : SPR_DOT_SMALL, PAL_NONE, ti, z, foundation_part);
 		} else if (_thd.drawstyle & HT_RAIL /*&& _thd.place_mode == VHM_RAIL*/) {
 			/* autorail highlight piece under cursor */
 			uint type = _thd.drawstyle & 0xF;
 			assert(type <= 5);
 			DrawAutorailSelection(ti, _AutorailType[type][0]);
 		} else if (IsPartOfAutoLine(ti->x, ti->y)) {
 			/* autorail highlighting long line */
 			int dir = _thd.drawstyle & ~0xF0;
 			uint side;
 			if (dir < 2) {
 				side = 0;
 			} else {
 				TileIndex start = TileVirtXY(_thd.selstart.x, _thd.selstart.y);
-				side = delta(delta(TileX(start), TileX(ti->tile)), delta(TileY(start), TileY(ti->tile)));
+				side = Delta(Delta(TileX(start), TileX(ti->tile)), Delta(TileY(start), TileY(ti->tile)));
 			}
 			DrawAutorailSelection(ti, _AutorailType[dir][side]);
 		}
 		return;
 	}
 	/* Check if it's inside the outer area? */
 	if (_thd.outersize.x &&
 			_thd.size.x < _thd.size.x + _thd.outersize.x &&
-			IS_INSIDE_1D(ti->x, _thd.pos.x + _thd.offs.x, _thd.size.x + _thd.outersize.x) &&
+			IsInsideBS(ti->x, _thd.pos.x + _thd.offs.x, _thd.size.x + _thd.outersize.x) &&
-			IS_INSIDE_1D(ti->y, _thd.pos.y + _thd.offs.y, _thd.size.y + _thd.outersize.y)) {
+			IsInsideBS(ti->y, _thd.pos.y + _thd.offs.y, _thd.size.y + _thd.outersize.y)) {
 		/* Draw a blue rect. */
 		DrawTileSelectionRect(ti, PALETTE_SEL_TILE_BLUE);
 		return;
 	}
 }
 			}
 			y_cur += 0x10;
 			x_cur -= 0x10;
-			_added_tile_sprite = false;
+			vd->foundation_part = FOUNDATION_PART_NONE;
-			_offset_ground_sprites = false;
+			vd->foundation[0] = NULL;
+			vd->foundation[1] = NULL;
+			vd->last_foundation_child[0] = NULL;
+			vd->last_foundation_child[1] = NULL;
 			_tile_type_procs[tt]->draw_tile_proc(&ti);
 			DrawTileSelection(&ti);
 		} while (--width_cur);
 static void ViewportAddTownNames(DrawPixelInfo *dpi)
 {
 	Town *t;
 	int left, top, right, bottom;
-	if (!HASBIT(_display_opt, DO_SHOW_TOWN_NAMES) || _game_mode == GM_MENU)
+	if (!HasBit(_display_opt, DO_SHOW_TOWN_NAMES) || _game_mode == GM_MENU)
 		return;
 	left = dpi->left;
 	top = dpi->top;
 	right = left + dpi->width;
 static void ViewportAddStationNames(DrawPixelInfo *dpi)
 {
 	int left, top, right, bottom;
 	const Station *st;
-	if (!HASBIT(_display_opt, DO_SHOW_STATION_NAMES) || _game_mode == GM_MENU)
+	if (!HasBit(_display_opt, DO_SHOW_STATION_NAMES) || _game_mode == GM_MENU)
 		return;
 	left = dpi->left;
 	top = dpi->top;
 	right = left + dpi->width;
 static void ViewportAddSigns(DrawPixelInfo *dpi)
 {
 	const Sign *si;
 	int left, top, right, bottom;
-	if (!HASBIT(_display_opt, DO_SHOW_SIGNS))
+	if (!HasBit(_display_opt, DO_SHOW_SIGNS))
 		return;
 	left = dpi->left;
 	top = dpi->top;
 	right = left + dpi->width;
 			FOR_ALL_SIGNS(si) {
 				if (bottom > si->sign.top &&
 						top    < si->sign.top + ScaleByZoom(12, dpi->zoom) &&
 						right  > si->sign.left &&
 						left   < si->sign.left + ScaleByZoom(si->sign.width_2, dpi->zoom)) {
-					AddSign(si, STR_2002, si->sign.width_2 | 0x8000);
+					AddSign(si, IsTransparencySet(TO_SIGNS) ? STR_2002_WHITE : STR_2002, si->sign.width_2 | 0x8000);
 				}
 			}
 			break;
 		default: NOT_REACHED();
 static void ViewportAddWaypoints(DrawPixelInfo *dpi)
 {
 	const Waypoint *wp;
 	int left, top, right, bottom;
-	if (!HASBIT(_display_opt, DO_WAYPOINTS))
+	if (!HasBit(_display_opt, DO_WAYPOINTS))
 		return;
 	left = dpi->left;
 	top = dpi->top;
 	right = left + dpi->width;
 				w -= 3;
 			}
 		/* Draw the rectangle if 'tranparent station signs' is off,
 		 * or if we are drawing a general text sign (STR_2806) */
-			if (!HASBIT(_transparent_opt, TO_SIGNS) || ss->string == STR_2806) {
+			if (!IsTransparencySet(TO_SIGNS) || ss->string == STR_2806) {
 				DrawFrameRect(
 					x, y, x + w, bottom, ss->color,
-					HASBIT(_transparent_opt, TO_SIGNS) ? FR_TRANSPARENT : FR_NONE
+					IsTransparencySet(TO_SIGNS) ? FR_TRANSPARENT : FR_NONE
 				);
 			}
 		}
 		SetDParam(0, ss->params[0]);
 		SetDParam(1, ss->params[1]);
 		/* if we didn't draw a rectangle, or if transparant building is on,
 		 * draw the text in the color the rectangle would have */
-		if (HASBIT(_transparent_opt, TO_SIGNS) && ss->string != STR_2806 && ss->width != 0) {
+		if (IsTransparencySet(TO_SIGNS) && ss->string != STR_2806 && ss->width != 0) {
 			/* Real colors need the IS_PALETTE_COLOR flag
 			 * otherwise colors from _string_colormap are assumed. */
 			colour = _colour_gradient[ss->color][6] | IS_PALETTE_COLOR;
 		} else {
-			colour = 16;
+			colour = TC_BLACK;
 		}
 		DrawString(
 			UnScaleByZoom(ss->x, zoom), UnScaleByZoom(ss->y, zoom) - (ss->width & 0x8000 ? 2 : 0),
 			ss->string, colour
 		);
 	 * Calculation is scaled by 4 to avoid rounding errors */
 	int vx = -x + y * 2;
 	int vy =  x + y * 2;
 	/* clamp to size of map */
-	vx = clamp(vx, 0, MapMaxX() * TILE_SIZE * 4);
+	vx = Clamp(vx, 0, MapMaxX() * TILE_SIZE * 4);
-	vy = clamp(vy, 0, MapMaxY() * TILE_SIZE * 4);
+	vy = Clamp(vy, 0, MapMaxY() * TILE_SIZE * 4);
 	/* Convert map coordinates to viewport coordinates */
 	x = (-vx + vy) / 2;
 	y = ( vx + vy) / 4;
 		if (delta_x != 0 || delta_y != 0) {
 			if (_patches.smooth_scroll) {
 				int max_scroll = ScaleByMapSize1D(512);
 				/* Not at our desired positon yet... */
-				WP(w, vp_d).scrollpos_x += clamp(delta_x / 4, -max_scroll, max_scroll);
+				WP(w, vp_d).scrollpos_x += Clamp(delta_x / 4, -max_scroll, max_scroll);
-				WP(w, vp_d).scrollpos_y += clamp(delta_y / 4, -max_scroll, max_scroll);
+				WP(w, vp_d).scrollpos_y += Clamp(delta_y / 4, -max_scroll, max_scroll);
 			} else {
 				WP(w, vp_d).scrollpos_x = WP(w, vp_d).dest_scrollpos_x;
 				WP(w, vp_d).scrollpos_y = WP(w, vp_d).dest_scrollpos_y;
 			}
 		}
 void MarkTileDirty(int x, int y)
 {
 	uint z = 0;
 	Point pt;
-	if (IS_INT_INSIDE(x, 0, MapSizeX() * TILE_SIZE) &&
+	if (IsInsideMM(x, 0, MapSizeX() * TILE_SIZE) &&
-			IS_INT_INSIDE(y, 0, MapSizeY() * TILE_SIZE))
+			IsInsideMM(y, 0, MapSizeY() * TILE_SIZE))
 		z = GetTileZ(TileVirtXY(x, y));
 	pt = RemapCoords(x, y, z);
 	MarkAllViewportsDirty(
 		pt.x - 31,
 static bool CheckClickOnTown(const ViewPort *vp, int x, int y)
 {
 	const Town *t;
-	if (!HASBIT(_display_opt, DO_SHOW_TOWN_NAMES)) return false;
+	if (!HasBit(_display_opt, DO_SHOW_TOWN_NAMES)) return false;
 	switch (vp->zoom) {
 		case ZOOM_LVL_NORMAL:
 			x = x - vp->left + vp->virtual_left;
 			y = y - vp->top  + vp->virtual_top;
 static bool CheckClickOnStation(const ViewPort *vp, int x, int y)
 {
 	const Station *st;
-	if (!HASBIT(_display_opt, DO_SHOW_STATION_NAMES)) return false;
+	if (!HasBit(_display_opt, DO_SHOW_STATION_NAMES)) return false;
 	switch (vp->zoom) {
 		case ZOOM_LVL_NORMAL:
 			x = x - vp->left + vp->virtual_left;
 			y = y - vp->top  + vp->virtual_top;
 static bool CheckClickOnSign(const ViewPort *vp, int x, int y)
 {
 	const Sign *si;
-	if (!HASBIT(_display_opt, DO_SHOW_SIGNS) || _current_player == PLAYER_SPECTATOR) return false;
+	if (!HasBit(_display_opt, DO_SHOW_SIGNS) || _current_player == PLAYER_SPECTATOR) return false;
 	switch (vp->zoom) {
 		case ZOOM_LVL_NORMAL:
 			x = x - vp->left + vp->virtual_left;
 			y = y - vp->top  + vp->virtual_top;
 static bool CheckClickOnWaypoint(const ViewPort *vp, int x, int y)
 {
 	const Waypoint *wp;
-	if (!HASBIT(_display_opt, DO_WAYPOINTS)) return false;
+	if (!HasBit(_display_opt, DO_WAYPOINTS)) return false;
 	switch (vp->zoom) {
 		case ZOOM_LVL_NORMAL:
 			x = x - vp->left + vp->virtual_left;
 			y = y - vp->top  + vp->virtual_top;
 	if (_thd.place_mode == VHM_SPECIAL) {
 		x1 = _thd.selend.x;
 		y1 = _thd.selend.y;
 		if (x1 != -1) {
-			int x2 = _thd.selstart.x;
+			int x2 = _thd.selstart.x & ~0xF;
-			int y2 = _thd.selstart.y;
+			int y2 = _thd.selstart.y & ~0xF;
 			x1 &= ~0xF;
 			y1 &= ~0xF;
 			if (x1 >= x2) Swap(x1, x2);
 			if (y1 >= y2) Swap(y1, y2);
 					x1 += 8;
 					y1 += 8;
 					break;
 				case VHM_RAIL:
 					_thd.new_drawstyle = GetAutorailHT(pt.x, pt.y); // draw one highlighted tile
+					break;
+				default:
+					NOT_REACHED();
+					break;
 			}
 			_thd.new_pos.x = x1 & ~0xF;
 			_thd.new_pos.y = y1 & ~0xF;
 		}
 	}
 		if (_thd.new_drawstyle) SetSelectionTilesDirty();
 	}
 }
 /** highlighting tiles while only going over them with the mouse */
-void VpStartPlaceSizing(TileIndex tile, byte method, byte process)
+void VpStartPlaceSizing(TileIndex tile, ViewportPlaceMethod method, byte process)
 {
 	_thd.select_method = method;
 	_thd.select_proc   = process;
 	_thd.selend.x = TileX(tile) * TILE_SIZE;
 	_thd.selstart.x = TileX(tile) * TILE_SIZE;
 	_thd.selend.y = TileY(tile) * TILE_SIZE;
 	_thd.selstart.y = TileY(tile) * TILE_SIZE;
+	/* Needed so several things (road, autoroad, bridges, ...) are placed correctly.
+	 * In effect, placement starts from the centre of a tile
+	 */
+	if (method == VPM_X_OR_Y || method == VPM_FIX_X || method == VPM_FIX_Y) {
+		_thd.selend.x += TILE_SIZE / 2;
+		_thd.selend.y += TILE_SIZE / 2;
+		_thd.selstart.x += TILE_SIZE / 2;
+		_thd.selstart.y += TILE_SIZE / 2;
+	}
 	if (_thd.place_mode == VHM_RECT) {
 		_thd.place_mode = VHM_SPECIAL;
 		_thd.next_drawstyle = HT_RECT;
 	} else if (_thd.place_mode == VHM_RAIL) { // autorail one piece
 		_thd.place_mode = VHM_SPECIAL;
 	HighLightStyle b;
 	uint w, h;
 	int dx = thd->selstart.x - (thd->selend.x & ~0xF);
 	int dy = thd->selstart.y - (thd->selend.y & ~0xF);
-	w = myabs(dx) + 16;
+	w = abs(dx) + 16;
-	h = myabs(dy) + 16;
+	h = abs(dy) + 16;
 	if (TileVirtXY(thd->selstart.x, thd->selstart.y) == TileVirtXY(x, y)) { // check if we're only within one tile
 		if (method == VPM_RAILDIRS) {
 			b = GetAutorailHT(x, y);
 		} else { // rect for autosignals on one tile
 * Selects tiles while dragging
 * @param x X coordinate of end of selection
 * @param y Y coordinate of end of selection
 * @param method modifies the way tiles are selected. Possible
 * methods are VPM_* in viewport.h */
-void VpSelectTilesWithMethod(int x, int y, int method)
+void VpSelectTilesWithMethod(int x, int y, ViewportPlaceMethod method)
 {
 	int sx, sy;
 	HighLightStyle style;
 	if (x == -1) {
 		_thd.selend.y = y;
 		CalcRaildirsDrawstyle(&_thd, x, y, method);
 		return;
 	}
+	/* Needed so level-land is placed correctly */
 	if (_thd.next_drawstyle == HT_POINT) {
 		x += TILE_SIZE / 2;
 		y += TILE_SIZE / 2;
 	}
 	sx = _thd.selstart.x;
 	sy = _thd.selstart.y;
 	switch (method) {
 		case VPM_X_OR_Y: /* drag in X or Y direction */
-			if (myabs(sy - y) < myabs(sx - x)) {
+			if (abs(sy - y) < abs(sx - x)) {
 				y = sy;
 				style = HT_DIR_X;
 			} else {
 				x = sx;
 				style = HT_DIR_Y;
 				GuiShowTooltipsWithArgs(measure_strings_length[index], index, params);
 			} break;
 		case VPM_X_AND_Y_LIMITED: { /* drag an X by Y constrained rect area */
 			int limit = (_thd.sizelimit - 1) * TILE_SIZE;
-			x = sx + clamp(x - sx, -limit, limit);
+			x = sx + Clamp(x - sx, -limit, limit);
-			y = sy + clamp(y - sy, -limit, limit);
+			y = sy + Clamp(y - sy, -limit, limit);
 			} /* Fallthrough */
 		case VPM_X_AND_Y: { /* drag an X by Y area */
 			if (_patches.measure_tooltip) {
 				static const StringID measure_strings_area[] = {
 					STR_NULL, STR_NULL, STR_MEASURE_AREA, STR_MEASURE_AREA_HEIGHTDIFF
 				};
 				TileIndex t0 = TileVirtXY(sx, sy);
 				TileIndex t1 = TileVirtXY(x, y);
-				uint dx = delta(TileX(t0), TileX(t1)) + 1;
+				uint dx = Delta(TileX(t0), TileX(t1)) + 1;
-				uint dy = delta(TileY(t0), TileY(t1)) + 1;
+				uint dy = Delta(TileY(t0), TileY(t1)) + 1;
 				byte index = 0;
 				uint64 params[3];
 				/* If dragging an area (eg dynamite tool) and it is actually a single
 				 * row/column, change the type to 'line' to get proper calculation for height */
 	w->wndproc(w, &e);
 	return false;
 }
-void SetObjectToPlaceWnd(CursorID icon, SpriteID pal, byte mode, Window *w)
+void SetObjectToPlaceWnd(CursorID icon, SpriteID pal, ViewportHighlightMode mode, Window *w)
 {
 	SetObjectToPlace(icon, pal, mode, w->window_class, w->window_number);
 }
 #include "table/animcursors.h"
-void SetObjectToPlace(CursorID icon, SpriteID pal, byte mode, WindowClass window_class, WindowNumber window_num)
+void SetObjectToPlace(CursorID icon, SpriteID pal, ViewportHighlightMode mode, WindowClass window_class, WindowNumber window_num)
 {
 	Window *w;
 	/* undo clicking on button */
-	if (_thd.place_mode != 0) {
+	if (_thd.place_mode != VHM_NONE) {
-		_thd.place_mode = 0;
+		_thd.place_mode = VHM_NONE;
 		w = FindWindowById(_thd.window_class, _thd.window_number);
 		if (w != NULL) CallWindowEventNP(w, WE_ABORT_PLACE_OBJ);
 	}
 	SetTileSelectSize(1, 1);
 	_thd.make_square_red = false;
-	if (mode == VHM_DRAG) { // mode 4 is for dragdropping trains in the depot window
+	if (mode == VHM_DRAG) { // VHM_DRAG is for dragdropping trains in the depot window
-		mode = 0;
+		mode = VHM_NONE;
 		_special_mouse_mode = WSM_DRAGDROP;
 	} else {
 		_special_mouse_mode = WSM_NONE;
 	}

branch	NewGRF_ports
changeset 6871	5a9dc001e1ad
parent 6870	ca3fd1fbe311
child 6872	1c4a4a609f85