Merge 57cea4e98c into ae917cb8c6

src/table/bridge_land.h

@@ -36,15 +36,10 @@
 # define MW(a) {a, PALETTE_TO_STRUCT_WHITE}
 # define MC(a) {a, PALETTE_TO_STRUCT_CONCRETE}
 
-/* Sprite table for middle part of aqueduct. */
-static const PalSpriteID _aqueduct_sprite_table_middle[] = {
-	{SPR_AQUEDUCT_MIDDLE_X, PAL_NONE}, {0x0, PAL_NONE}, {SPR_AQUEDUCT_PILLAR_X, PAL_NONE}, {0x0, PAL_NONE}, // AXIS_X
-	{SPR_AQUEDUCT_MIDDLE_Y, PAL_NONE}, {0x0, PAL_NONE}, {SPR_AQUEDUCT_PILLAR_Y, PAL_NONE}, {0x0, PAL_NONE}, // AIXS_Y
-};
-
-/* Sprite table for head part of aqueduct. */
-static const PalSpriteID _aqueduct_sprite_table_heads[] = {
-	{SPR_AQUEDUCT_RAMP_SW, PAL_NONE}, {SPR_AQUEDUCT_RAMP_SE, PAL_NONE}, {SPR_AQUEDUCT_RAMP_NE, PAL_NONE}, {SPR_AQUEDUCT_RAMP_NW, PAL_NONE},
+static const PalSpriteID _aqueduct_sprites[] = {
+	{ SPR_AQUEDUCT_MIDDLE_X, PAL_NONE }, {                  0x0, PAL_NONE }, { SPR_AQUEDUCT_PILLAR_X, PAL_NONE }, {                  0x0, PAL_NONE },
+	{ SPR_AQUEDUCT_MIDDLE_Y, PAL_NONE }, {                  0x0, PAL_NONE }, { SPR_AQUEDUCT_PILLAR_Y, PAL_NONE }, {                  0x0, PAL_NONE },
+	{  SPR_AQUEDUCT_RAMP_SW, PAL_NONE }, { SPR_AQUEDUCT_RAMP_SE, PAL_NONE }, {  SPR_AQUEDUCT_RAMP_NE, PAL_NONE }, { SPR_AQUEDUCT_RAMP_NW, PAL_NONE },
 };
 
 static const PalSpriteID _bridge_sprite_table_4_0[] = {

src/tunnelbridge_cmd.cpp

@@ -138,58 +138,15 @@ bool HasBridgeFlatRamp(Slope tileh, Axis axis)
 	return (tileh != SLOPE_FLAT);
 }
 
-/**
- * Get the sprite table for a rail/road bridge piece.
- * @param bridge_type Bridge type.
- * @param piece Bridge piece.
- * @return Sprite table for the bridge piece.
- */
-static std::span<const PalSpriteID> GetBridgeSpriteTable(BridgeType bridge_type, BridgePieces piece)
+static inline std::span<const PalSpriteID> GetBridgeSpriteTable(int index, BridgePieces table)
 {
-	assert(piece < NUM_BRIDGE_PIECES);
+	const BridgeSpec *bridge = GetBridgeSpec(index);
+	assert(table < NUM_BRIDGE_PIECES);
+	if (table < bridge->sprite_table.size() && !bridge->sprite_table[table].empty()) return bridge->sprite_table[table];
 
-	const BridgeSpec *bridge = GetBridgeSpec(bridge_type);
-	if (piece < bridge->sprite_table.size() && !bridge->sprite_table[piece].empty()) return bridge->sprite_table[piece];
-
-	return _bridge_sprite_table[bridge_type][piece];
+	return _bridge_sprite_table[index][table];
 }
 
-/**
- * Get the sprite table transport type base offset for a rail/road bridge.
- * @param transport_type Transport type of bridge.
- * @param ramp Tile of bridge ramp.
- * @return Offset for transport type.
- */
-static uint8_t GetBridgeSpriteTableBaseOffset(TransportType transport_type, TileIndex ramp)
-{
-	switch (transport_type) {
-		case TRANSPORT_RAIL: return GetRailTypeInfo(GetRailType(ramp))->bridge_offset;
-		case TRANSPORT_ROAD: return 8;
-		default: NOT_REACHED();
-	}
-}
-
-/**
- * Get bridge sprite table base offset for the ramp part of bridge.
- * @param diagdir Direction of ramp.
- * @return Offset for direction.
- */
-static uint8_t GetBridgeRampDirectionBaseOffset(DiagDirection diagdir)
-{
-	/* Bridge ramps are ordered SW, SE, NE, NW instead of NE, SE, SW, NW. */
-	static constexpr uint8_t ramp_offsets[DIAGDIR_END] = {2, 1, 0, 3};
-	return ramp_offsets[diagdir];
-}
-
-/**
- * Get bridge sprite table base offset for the middle part of bridge.
- * @param axis Axis of bridge.
- * @return Offset for axis.
- */
-static uint8_t GetBridgeMiddleAxisBaseOffset(Axis axis)
-{
-	return axis == AXIS_X ? 0 : 4;
-}
 
 /**
  * Determines the foundation for the bridge head, and tests if the resulting slope is valid.
@@ -1060,10 +1017,10 @@ static CommandCost ClearTile_TunnelBridge(TileIndex tile, DoCommandFlags flags)
  * @param h         Bounding box size in Y direction
  * @param subsprite Optional subsprite for drawing halfpillars
  */
-static inline void DrawPillar(const PalSpriteID &psid, int x, int y, int z, uint8_t w, uint8_t h, const SubSprite *subsprite)
+static inline void DrawPillar(const PalSpriteID *psid, int x, int y, int z, uint8_t w, uint8_t h, const SubSprite *subsprite)
 {
 	static const int PILLAR_Z_OFFSET = TILE_HEIGHT - BRIDGE_Z_START; ///< Start offset of pillar wrt. bridge (downwards)
-	AddSortableSpriteToDraw(psid.sprite, psid.pal, x, y, z, {{0, 0, -PILLAR_Z_OFFSET}, {w, h, BB_HEIGHT_UNDER_BRIDGE}, {0, 0, PILLAR_Z_OFFSET}}, IsTransparencySet(TO_BRIDGES), subsprite);
+	AddSortableSpriteToDraw(psid->sprite, psid->pal, x, y, z, {{0, 0, -PILLAR_Z_OFFSET}, {w, h, BB_HEIGHT_UNDER_BRIDGE}, {0, 0, PILLAR_Z_OFFSET}}, IsTransparencySet(TO_BRIDGES), subsprite);
 }
 
 /**
@@ -1077,7 +1034,7 @@ static inline void DrawPillar(const PalSpriteID &psid, int x, int y, int z, uint
  * @param h        Bounding box size in Y direction
  * @return Reached Z at the bottom
  */
-static int DrawPillarColumn(int z_bottom, int z_top, const PalSpriteID &psid, int x, int y, int w, int h)
+static int DrawPillarColumn(int z_bottom, int z_top, const PalSpriteID *psid, int x, int y, int w, int h)
 {
 	int cur_z;
 	for (cur_z = z_top; cur_z >= z_bottom; cur_z -= TILE_HEIGHT) {
@@ -1097,7 +1054,7 @@ static int DrawPillarColumn(int z_bottom, int z_top, const PalSpriteID &psid, in
  * @param y Sprite Y position of front pillar.
  * @param z_bridge Absolute height of bridge bottom.
  */
-static void DrawBridgePillars(const PalSpriteID &psid, const TileInfo *ti, Axis axis, bool drawfarpillar, int x, int y, int z_bridge)
+static void DrawBridgePillars(const PalSpriteID *psid, const TileInfo *ti, Axis axis, bool drawfarpillar, int x, int y, int z_bridge)
 {
 	static const int bounding_box_size[2]  = {16, 2}; ///< bounding box size of pillars along bridge direction
 	static const int back_pillar_offset[2] = { 0, 9}; ///< sprite position offset of back facing pillar
@@ -1108,7 +1065,7 @@ static void DrawBridgePillars(const PalSpriteID &psid, const TileInfo *ti, Axis
 		{ { -INF, -INF,  15, INF }, {   16, -INF, INF, INF } }, // Y axis, north and south
 	};
 
-	if (psid.sprite == 0) return;
+	if (psid->sprite == 0) return;
 
 	/* Determine ground height under pillars */
 	DiagDirection south_dir = AxisToDiagDir(axis);
@@ -1447,20 +1404,34 @@ static void DrawTile_TunnelBridge(TileInfo *ti)
 
 		DrawBridgeMiddle(ti);
 	} else { // IsBridge(ti->tile)
+		const PalSpriteID *psid;
+		int base_offset;
+		bool ice = HasTunnelBridgeSnowOrDesert(ti->tile);
+
+		if (transport_type == TRANSPORT_RAIL) {
+			base_offset = GetRailTypeInfo(GetRailType(ti->tile))->bridge_offset;
+			assert(base_offset != 8); // This one is used for roads
+		} else {
+			base_offset = 8;
+		}
+
+		/* as the lower 3 bits are used for other stuff, make sure they are clear */
+		assert( (base_offset & 0x07) == 0x00);
+
 		DrawFoundation(ti, GetBridgeFoundation(ti->tileh, DiagDirToAxis(tunnelbridge_direction)));
 
-		uint base_offset = GetBridgeRampDirectionBaseOffset(tunnelbridge_direction);
-		std::span<const PalSpriteID> psid;
+		/* HACK Wizardry to convert the bridge ramp direction into a sprite offset */
+		base_offset += (6 - tunnelbridge_direction) % 4;
+
+		/* Table number BRIDGE_PIECE_HEAD always refers to the bridge heads for any bridge type */
 		if (transport_type != TRANSPORT_WATER) {
 			if (ti->tileh == SLOPE_FLAT) base_offset += 4; // sloped bridge head
-			base_offset += GetBridgeSpriteTableBaseOffset(transport_type, ti->tile);
-			psid = GetBridgeSpriteTable(GetBridgeType(ti->tile), BRIDGE_PIECE_HEAD);
+			psid = &GetBridgeSpriteTable(GetBridgeType(ti->tile), BRIDGE_PIECE_HEAD)[base_offset];
 		} else {
-			psid = _aqueduct_sprite_table_heads;
+			psid = _aqueduct_sprites + base_offset;
 		}
-		psid = psid.subspan(base_offset, 1);
 
-		if (!HasTunnelBridgeSnowOrDesert(ti->tile)) {
+		if (!ice) {
 			TileIndex next = ti->tile + TileOffsByDiagDir(tunnelbridge_direction);
 			if (ti->tileh != SLOPE_FLAT && ti->z == 0 && HasTileWaterClass(next) && GetWaterClass(next) == WATER_CLASS_SEA) {
 				DrawShoreTile(ti->tileh);
@@ -1480,7 +1451,7 @@ static void DrawTile_TunnelBridge(TileInfo *ti)
 		 * it doesn't disappear behind it
 		 */
 		/* Bridge heads are drawn solid no matter how invisibility/transparency is set */
-		AddSortableSpriteToDraw(psid[0].sprite, psid[0].pal, *ti, {{}, {TILE_SIZE, TILE_SIZE, static_cast<uint8_t>(ti->tileh == SLOPE_FLAT ? 0 : TILE_HEIGHT)}, {}});
+		AddSortableSpriteToDraw(psid->sprite, psid->pal, *ti, {{}, {TILE_SIZE, TILE_SIZE, static_cast<uint8_t>(ti->tileh == SLOPE_FLAT ? 0 : TILE_HEIGHT)}, {}});
 
 		if (transport_type == TRANSPORT_ROAD) {
 			uint offset = tunnelbridge_direction;
@@ -1601,21 +1572,33 @@ void DrawBridgeMiddle(const TileInfo *ti)
 	TileIndex rampnorth = GetNorthernBridgeEnd(ti->tile);
 	TileIndex rampsouth = GetSouthernBridgeEnd(ti->tile);
 	TransportType transport_type = GetTunnelBridgeTransportType(rampsouth);
-	Axis axis = GetBridgeAxis(ti->tile);
 
-	uint base_offset = GetBridgeMiddleAxisBaseOffset(axis);
-	std::span<const PalSpriteID> psid;
+	Axis axis = GetBridgeAxis(ti->tile);
+	BridgePieces piece = CalcBridgePiece(
+		GetTunnelBridgeLength(ti->tile, rampnorth) + 1,
+		GetTunnelBridgeLength(ti->tile, rampsouth) + 1
+	);
+
+	const PalSpriteID *psid;
 	bool drawfarpillar;
 	if (transport_type != TRANSPORT_WATER) {
-		BridgeType bridge_type = GetBridgeType(rampsouth);
-		drawfarpillar = !HasBit(GetBridgeSpec(bridge_type)->flags, 0);
-		base_offset += GetBridgeSpriteTableBaseOffset(transport_type, rampsouth);
-		psid = GetBridgeSpriteTable(bridge_type, CalcBridgePiece(GetTunnelBridgeLength(ti->tile, rampnorth) + 1, GetTunnelBridgeLength(ti->tile, rampsouth) + 1));
+		BridgeType type =  GetBridgeType(rampsouth);
+		drawfarpillar = !HasBit(GetBridgeSpec(type)->flags, 0);
+
+		uint base_offset;
+		if (transport_type == TRANSPORT_RAIL) {
+			base_offset = GetRailTypeInfo(GetRailType(rampsouth))->bridge_offset;
+		} else {
+			base_offset = 8;
+		}
+
+		psid = &GetBridgeSpriteTable(type, piece)[base_offset];
 	} else {
 		drawfarpillar = true;
-		psid = _aqueduct_sprite_table_middle;
+		psid = _aqueduct_sprites;
 	}
-	psid = psid.subspan(base_offset, 3);
+
+	if (axis != AXIS_X) psid += 4;
 
 	int x = ti->x;
 	int y = ti->y;
@@ -1631,12 +1614,14 @@ void DrawBridgeMiddle(const TileInfo *ti)
 	/* Draw floor and far part of bridge*/
 	if (!IsInvisibilitySet(TO_BRIDGES)) {
 		if (axis == AXIS_X) {
-			AddSortableSpriteToDraw(psid[0].sprite, psid[0].pal, x, y, z, {{0, 0, BRIDGE_Z_START}, {TILE_SIZE, 1, 40}, {0, 0, -BRIDGE_Z_START}}, IsTransparencySet(TO_BRIDGES));
+			AddSortableSpriteToDraw(psid->sprite, psid->pal, x, y, z, {{0, 0, BRIDGE_Z_START}, {TILE_SIZE, 1, 40}, {0, 0, -BRIDGE_Z_START}}, IsTransparencySet(TO_BRIDGES));
 		} else {
-			AddSortableSpriteToDraw(psid[0].sprite, psid[0].pal, x, y, z, {{0, 0, BRIDGE_Z_START}, {1, TILE_SIZE, 40}, {0, 0, -BRIDGE_Z_START}}, IsTransparencySet(TO_BRIDGES));
+			AddSortableSpriteToDraw(psid->sprite, psid->pal, x, y, z, {{0, 0, BRIDGE_Z_START}, {1, TILE_SIZE, 40}, {0, 0, -BRIDGE_Z_START}}, IsTransparencySet(TO_BRIDGES));
 		}
 	}
 
+	psid++;
+
 	if (transport_type == TRANSPORT_ROAD) {
 		/* DrawBridgeRoadBits() calls EndSpriteCombine() and StartSpriteCombine() */
 		DrawBridgeRoadBits(rampsouth, x, y, bridge_z, axis ^ 1, false);
@@ -1669,10 +1654,10 @@ void DrawBridgeMiddle(const TileInfo *ti)
 	if (!IsInvisibilitySet(TO_BRIDGES)) {
 		if (axis == AXIS_X) {
 			y += 12;
-			if (psid[1].sprite & SPRITE_MASK) AddSortableSpriteToDraw(psid[1].sprite, psid[1].pal, x, y, z, {{0, 3, BRIDGE_Z_START}, {TILE_SIZE, 1, 40}, {0, -3, -BRIDGE_Z_START}}, IsTransparencySet(TO_BRIDGES));
+			if (psid->sprite & SPRITE_MASK) AddSortableSpriteToDraw(psid->sprite, psid->pal, x, y, z, {{0, 3, BRIDGE_Z_START}, {TILE_SIZE, 1, 40}, {0, -3, -BRIDGE_Z_START}}, IsTransparencySet(TO_BRIDGES));
 		} else {
 			x += 12;
-			if (psid[1].sprite & SPRITE_MASK) AddSortableSpriteToDraw(psid[1].sprite, psid[1].pal, x, y, z, {{3, 0, BRIDGE_Z_START}, {1, TILE_SIZE, 40}, {-3, 0, -BRIDGE_Z_START}}, IsTransparencySet(TO_BRIDGES));
+			if (psid->sprite & SPRITE_MASK) AddSortableSpriteToDraw(psid->sprite, psid->pal, x, y, z, {{3, 0, BRIDGE_Z_START}, {1, TILE_SIZE, 40}, {-3, 0, -BRIDGE_Z_START}}, IsTransparencySet(TO_BRIDGES));
 		}
 	}
 
@@ -1682,7 +1667,8 @@ void DrawBridgeMiddle(const TileInfo *ti)
 	/* Do not draw anything more if bridges are invisible */
 	if (IsInvisibilitySet(TO_BRIDGES)) return;
 
-	DrawBridgePillars(psid[2], ti, axis, drawfarpillar, x, y, z);
+	psid++;
+	DrawBridgePillars(psid, ti, axis, drawfarpillar, x, y, z);
 }