slope_func.h

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * 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.
 * 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.
 * 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/>.
 */
 
#ifndef SLOPE_FUNC_H
#define SLOPE_FUNC_H
 
#include "core/math_func.hpp"
#include "slope_type.h"
#include "direction_type.h"
#include "tile_type.h"
 
static constexpr inline bool IsValidCorner(Corner corner)
{
  return IsInsideMM(corner, 0, CORNER_END);
}
 
 
static constexpr inline bool IsSteepSlope(Slope s)
{
  return (s & SLOPE_STEEP) != 0;
}
 
static constexpr inline bool IsHalftileSlope(Slope s)
{
  return (s & SLOPE_HALFTILE) != 0;
}
 
static constexpr inline Slope RemoveHalftileSlope(Slope s)
{
  return s & ~SLOPE_HALFTILE_MASK;
}
 
inline Slope ComplementSlope(Slope s)
{
  assert(!IsSteepSlope(s) && !IsHalftileSlope(s));
  return s ^ SLOPE_ELEVATED;
}
 
inline bool IsSlopeWithOneCornerRaised(Slope s)
{
  return (s == SLOPE_W) || (s == SLOPE_S) || (s == SLOPE_E) || (s == SLOPE_N);
}
 
inline Slope SlopeWithOneCornerRaised(Corner corner)
{
  assert(IsValidCorner(corner));
  return (Slope)(1 << corner);
}
 
inline bool HasSlopeHighestCorner(Slope s)
{
  s = RemoveHalftileSlope(s);
  return IsSteepSlope(s) || IsSlopeWithOneCornerRaised(s);
}
 
inline Corner GetHighestSlopeCorner(Slope s)
{
  switch (RemoveHalftileSlope(s)) {
    case SLOPE_W:
    case SLOPE_STEEP_W: return CORNER_W;
    case SLOPE_S:
    case SLOPE_STEEP_S: return CORNER_S;
    case SLOPE_E:
    case SLOPE_STEEP_E: return CORNER_E;
    case SLOPE_N:
    case SLOPE_STEEP_N: return CORNER_N;
    default: NOT_REACHED();
  }
}
 
static constexpr inline Corner GetHalftileSlopeCorner(Slope s)
{
  assert(IsHalftileSlope(s));
  return (Corner)((s >> 6) & 3);
}
 
static constexpr inline int GetSlopeMaxZ(Slope s)
{
  if (s == SLOPE_FLAT) return 0;
  if (IsSteepSlope(s)) return 2;
  return 1;
}
 
static constexpr inline int GetSlopeMaxPixelZ(Slope s)
{
  return GetSlopeMaxZ(s) * TILE_HEIGHT;
}
 
inline Corner OppositeCorner(Corner corner)
{
  return (Corner)(corner ^ 2);
}
 
inline bool IsSlopeWithThreeCornersRaised(Slope s)
{
  return !IsHalftileSlope(s) && !IsSteepSlope(s) && IsSlopeWithOneCornerRaised(ComplementSlope(s));
}
 
inline Slope SlopeWithThreeCornersRaised(Corner corner)
{
  return ComplementSlope(SlopeWithOneCornerRaised(corner));
}
 
inline Slope SteepSlope(Corner corner)
{
  return SLOPE_STEEP | SlopeWithThreeCornersRaised(OppositeCorner(corner));
}
 
inline bool IsInclinedSlope(Slope s)
{
  return (s == SLOPE_NW) || (s == SLOPE_SW) || (s == SLOPE_SE) || (s == SLOPE_NE);
}
 
inline DiagDirection GetInclinedSlopeDirection(Slope s)
{
  switch (s) {
    case SLOPE_NE: return DIAGDIR_NE;
    case SLOPE_SE: return DIAGDIR_SE;
    case SLOPE_SW: return DIAGDIR_SW;
    case SLOPE_NW: return DIAGDIR_NW;
    default: return INVALID_DIAGDIR;
  }
}
 
inline Slope InclinedSlope(DiagDirection dir)
{
  switch (dir) {
    case DIAGDIR_NE: return SLOPE_NE;
    case DIAGDIR_SE: return SLOPE_SE;
    case DIAGDIR_SW: return SLOPE_SW;
    case DIAGDIR_NW: return SLOPE_NW;
    default: NOT_REACHED();
  }
}
 
static constexpr inline Slope HalftileSlope(Slope s, Corner corner)
{
  assert(IsValidCorner(corner));
  return (Slope)(s | SLOPE_HALFTILE | (corner << 6));
}
 
 
inline bool IsFoundation(Foundation f)
{
  return f != FOUNDATION_NONE;
}
 
inline bool IsLeveledFoundation(Foundation f)
{
  return f == FOUNDATION_LEVELED;
}
 
inline bool IsInclinedFoundation(Foundation f)
{
  return (f == FOUNDATION_INCLINED_X) || (f == FOUNDATION_INCLINED_Y);
}
 
inline bool IsNonContinuousFoundation(Foundation f)
{
  return IsInsideMM(f, FOUNDATION_STEEP_BOTH, FOUNDATION_HALFTILE_N + 1);
}
 
inline Corner GetHalftileFoundationCorner(Foundation f)
{
  assert(IsInsideMM(f, FOUNDATION_HALFTILE_W, FOUNDATION_HALFTILE_N + 1));
  return (Corner)(f - FOUNDATION_HALFTILE_W);
}
 
inline bool IsSpecialRailFoundation(Foundation f)
{
  return IsInsideMM(f, FOUNDATION_RAIL_W, FOUNDATION_RAIL_N + 1);
}
 
inline Corner GetRailFoundationCorner(Foundation f)
{
  assert(IsSpecialRailFoundation(f));
  return (Corner)(f - FOUNDATION_RAIL_W);
}
 
inline Foundation FlatteningFoundation(Slope s)
{
  return (s == SLOPE_FLAT ? FOUNDATION_NONE : FOUNDATION_LEVELED);
}
 
inline Foundation InclinedFoundation(Axis axis)
{
  return (axis == AXIS_X ? FOUNDATION_INCLINED_X : FOUNDATION_INCLINED_Y);
}
 
inline Foundation HalftileFoundation(Corner corner)
{
  assert(IsValidCorner(corner));
  return static_cast<Foundation>(static_cast<uint>(FOUNDATION_HALFTILE_W) + static_cast<uint>(corner));
}
 
inline Foundation SpecialRailFoundation(Corner corner)
{
  assert(IsValidCorner(corner));
  return static_cast<Foundation>(static_cast<uint>(FOUNDATION_RAIL_W) + static_cast<uint>(corner));
}
 
inline uint SlopeToSpriteOffset(Slope s)
{
  extern const byte _slope_to_sprite_offset[32];
  return _slope_to_sprite_offset[s];
}
 
#endif /* SLOPE_FUNC_H */