direction_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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#ifndef DIRECTION_FUNC_H
#define DIRECTION_FUNC_H
 
#include "direction_type.h"

inline bool IsValidDiagDirection(DiagDirection d)
{
  return d < DiagDirection::End;
}

inline bool IsValidDirection(Direction d)
{
  return d < Direction::End;
}

inline bool IsValidAxis(Axis d)
{
  return d < Axis::End;
}

inline Direction ReverseDir(Direction d)
{
  assert(IsValidDirection(d));
  return static_cast<Direction>(4 ^ to_underlying(d));
}
 

inline DirDiff DirDifference(Direction d0, Direction d1)
{
  assert(IsValidDirection(d0));
  assert(IsValidDirection(d1));
  /* Cast to uint so compiler can use bitmask. If the difference is negative
   * and we used int instead of uint, further "+ 8" would have to be added. */
  return static_cast<DirDiff>((to_underlying(d0) - to_underlying(d1)) % 8);
}

inline DirDiff ChangeDirDiff(DirDiff d, DirDiff delta)
{
  /* Cast to uint so compiler can use bitmask. Result can never be negative. */
  return static_cast<DirDiff>((to_underlying(d) + to_underlying(delta)) % 8);
}

inline DirDiff LimitDirDiff(DirDiff d)
{
  return d > DirDiff::Reverse ? DirDiff::Left45 : DirDiff::Right45;
}

inline Direction ChangeDir(Direction d, DirDiff delta)
{
  assert(IsValidDirection(d));
  /* Cast to uint so compiler can use bitmask. Result can never be negative. */
  return static_cast<Direction>((to_underlying(d) + to_underlying(delta)) % 8);
}
 

inline DiagDirection ReverseDiagDir(DiagDirection d)
{
  assert(IsValidDiagDirection(d));
  return static_cast<DiagDirection>(2 ^ to_underlying(d));
}

inline DiagDirDiff DiagDirDifference(DiagDirection d0, DiagDirection d1)
{
  assert(IsValidDiagDirection(d0));
  assert(IsValidDiagDirection(d1));
  /* Cast to uint so compiler can use bitmask. Result can never be negative. */
  return static_cast<DiagDirDiff>((to_underlying(d0) - to_underlying(d1)) % 4);
}

inline DiagDirection ChangeDiagDir(DiagDirection d, DiagDirDiff delta)
{
  assert(IsValidDiagDirection(d));
  /* Cast to uint so compiler can use bitmask. Result can never be negative. */
  return static_cast<DiagDirection>((to_underlying(d) + to_underlying(delta)) % 4);
}

inline DiagDirection DirToDiagDir(Direction dir)
{
  assert(IsValidDirection(dir));
  return static_cast<DiagDirection>(to_underlying(dir) >> 1);
}

inline Direction DiagDirToDir(DiagDirection dir)
{
  assert(IsValidDiagDirection(dir));
  return static_cast<Direction>(to_underlying(dir) * 2 + 1);
}
 

inline Axis OtherAxis(Axis a)
{
  assert(IsValidAxis(a));
  return static_cast<Axis>(to_underlying(a) ^ 1);
}
 

inline Axis DiagDirToAxis(DiagDirection d)
{
  assert(IsValidDiagDirection(d));
  return static_cast<Axis>(to_underlying(d) & 1);
}
 

inline DiagDirection AxisToDiagDir(Axis a)
{
  assert(IsValidAxis(a));
  return static_cast<DiagDirection>(2 - to_underlying(a));
}

inline DiagDirections AxisToDiagDirs(Axis a)
{
  assert(IsValidAxis(a));
  return a == Axis::X
    ? DiagDirections{DiagDirection::NE, DiagDirection::SW}
    : DiagDirections{DiagDirection::SE, DiagDirection::NW};
}

inline Direction AxisToDirection(Axis a)
{
  assert(IsValidAxis(a));
  return static_cast<Direction>(5 - 2 * to_underlying(a));
}

inline DiagDirection XYNSToDiagDir(Axis xy, uint ns)
{
  assert(IsValidAxis(xy));
  return static_cast<DiagDirection>(to_underlying(xy) * 3 ^ ns * 2);
}

inline bool IsDiagonalDirection(Direction dir)
{
  assert(IsValidDirection(dir));
  return (to_underlying(dir) & 1) != 0;
}
 
#endif /* DIRECTION_FUNC_H */