src/direction_func.h

   1 /*
   2  * This file is part of OpenTTD.
   3  * 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.
   4  * 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.
   5  * 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/>.
   6  */
   7
   8 /** @file direction_func.h Different functions related to conversions between directions. */
   9
  10 #ifndef DIRECTION_FUNC_H
  11 #define DIRECTION_FUNC_H
  12
  13 #include "direction_type.h"
  14
  15 /**
  16  * Checks if an integer value is a valid DiagDirection
  17  *
  18  * @param d The value to check
  19  * @return True if the value belongs to a DiagDirection, else false
  20  */
  21 inline bool IsValidDiagDirection(DiagDirection d)
  22 {
  23         return d < DIAGDIR_END;
  24 }
  25
  26 /**
  27  * Checks if an integer value is a valid Direction
  28  *
  29  * @param d The value to check
  30  * @return True if the value belongs to a Direction, else false
  31  */
  32 inline bool IsValidDirection(Direction d)
  33 {
  34         return d < DIR_END;
  35 }
  36
  37 /**
  38  * Checks if an integer value is a valid Axis
  39  *
  40  * @param d The value to check
  41  * @return True if the value belongs to an Axis, else false
  42  */
  43 inline bool IsValidAxis(Axis d)
  44 {
  45         return d < AXIS_END;
  46 }
  47
  48 /**
  49  * Return the reverse of a direction
  50  *
  51  * @param d The direction to get the reverse from
  52  * @return The reverse Direction
  53  */
  54 inline Direction ReverseDir(Direction d)
  55 {
  56         assert(IsValidDirection(d));
  57         return (Direction)(4 ^ d);
  58 }
  59
  60
  61 /**
  62  * Calculate the difference between two directions
  63  *
  64  * @param d0 The first direction as the base
  65  * @param d1 The second direction as the offset from the base
  66  * @return The difference how the second direction drifts of the first one.
  67  */
  68 inline DirDiff DirDifference(Direction d0, Direction d1)
  69 {
  70         assert(IsValidDirection(d0));
  71         assert(IsValidDirection(d1));
  72         /* Cast to uint so compiler can use bitmask. If the difference is negative
  73          * and we used int instead of uint, further "+ 8" would have to be added. */
  74         return static_cast<DirDiff>((static_cast<uint>(d0) - static_cast<uint>(d1)) % 8);
  75 }
  76
  77 /**
  78  * Applies two differences together
  79  *
  80  * This function adds two differences together and returns the resulting
  81  * difference. So adding two DIRDIFF_REVERSE together results in the
  82  * DIRDIFF_SAME difference.
  83  *
  84  * @param d The first difference
  85  * @param delta The second difference to add on
  86  * @return The resulting difference
  87  */
  88 inline DirDiff ChangeDirDiff(DirDiff d, DirDiff delta)
  89 {
  90         /* Cast to uint so compiler can use bitmask. Result can never be negative. */
  91         return static_cast<DirDiff>((static_cast<uint>(d) + static_cast<uint>(delta)) % 8);
  92 }
  93
  94 /**
  95  * Change a direction by a given difference
  96  *
  97  * This functions returns a new direction of the given direction
  98  * which is rotated by the given difference.
  99  *
 100  * @param d The direction to get a new direction from
 101  * @param delta The offset/drift applied to the direction
 102  * @return The new direction
 103  */
 104 inline Direction ChangeDir(Direction d, DirDiff delta)
 105 {
 106         assert(IsValidDirection(d));
 107         /* Cast to uint so compiler can use bitmask. Result can never be negative. */
 108         return static_cast<Direction>((static_cast<uint>(d) + static_cast<uint>(delta)) % 8);
 109 }
 110
 111
 112 /**
 113  * Returns the reverse direction of the given DiagDirection
 114  *
 115  * @param d The DiagDirection to get the reverse from
 116  * @return The reverse direction
 117  */
 118 inline DiagDirection ReverseDiagDir(DiagDirection d)
 119 {
 120         assert(IsValidDiagDirection(d));
 121         return (DiagDirection)(2 ^ d);
 122 }
 123
 124 /**
 125  * Calculate the difference between two DiagDirection values
 126  *
 127  * @param d0 The first direction as the base
 128  * @param d1 The second direction as the offset from the base
 129  * @return The difference how the second direction drifts of the first one.
 130  */
 131 inline DiagDirDiff DiagDirDifference(DiagDirection d0, DiagDirection d1)
 132 {
 133         assert(IsValidDiagDirection(d0));
 134         assert(IsValidDiagDirection(d1));
 135         /* Cast to uint so compiler can use bitmask. Result can never be negative. */
 136         return (DiagDirDiff)((uint)(d0 - d1) % 4);
 137 }
 138
 139 /**
 140  * Applies a difference on a DiagDirection
 141  *
 142  * This function applies a difference on a DiagDirection and returns
 143  * the new DiagDirection.
 144  *
 145  * @param d The DiagDirection
 146  * @param delta The difference to apply on
 147  * @return The new direction which was calculated
 148  */
 149 inline DiagDirection ChangeDiagDir(DiagDirection d, DiagDirDiff delta)
 150 {
 151         assert(IsValidDiagDirection(d));
 152         /* Cast to uint so compiler can use bitmask. Result can never be negative. */
 153         return static_cast<DiagDirection>((static_cast<uint>(d) + static_cast<uint>(delta)) % 4);
 154 }
 155
 156 /**
 157  * Convert a Direction to a DiagDirection.
 158  *
 159  * This function can be used to convert the 8-way Direction to
 160  * the 4-way DiagDirection. If the direction cannot be mapped its
 161  * "rounded clockwise". So DIR_N becomes DIAGDIR_NE.
 162  *
 163  * @param dir The direction to convert
 164  * @return The resulting DiagDirection, maybe "rounded clockwise".
 165  */
 166 inline DiagDirection DirToDiagDir(Direction dir)
 167 {
 168         assert(IsValidDirection(dir));
 169         return (DiagDirection)(dir >> 1);
 170 }
 171
 172 /**
 173  * Convert a DiagDirection to a Direction.
 174  *
 175  * This function can be used to convert the 4-way DiagDirection
 176  * to the 8-way Direction. As 4-way are less than 8-way not all
 177  * possible directions can be calculated.
 178  *
 179  * @param dir The direction to convert
 180  * @return The resulting Direction
 181  */
 182 inline Direction DiagDirToDir(DiagDirection dir)
 183 {
 184         assert(IsValidDiagDirection(dir));
 185         return (Direction)(dir * 2 + 1);
 186 }
 187
 188
 189 /**
 190  * Select the other axis as provided.
 191  *
 192  * This is basically the not-operator for the axis.
 193  *
 194  * @param a The given axis
 195  * @return The other axis
 196  */
 197 inline Axis OtherAxis(Axis a)
 198 {
 199         assert(IsValidAxis(a));
 200         return (Axis)(a ^ 1);
 201 }
 202
 203
 204 /**
 205  * Convert a DiagDirection to the axis.
 206  *
 207  * This function returns the axis which belongs to the given
 208  * DiagDirection. The axis X belongs to the DiagDirection
 209  * north-east and south-west.
 210  *
 211  * @param d The DiagDirection
 212  * @return The axis which belongs to the direction
 213  */
 214 inline Axis DiagDirToAxis(DiagDirection d)
 215 {
 216         assert(IsValidDiagDirection(d));
 217         return (Axis)(d & 1);
 218 }
 219
 220
 221 /**
 222  * Converts an Axis to a DiagDirection
 223  *
 224  * This function returns the DiagDirection which
 225  * belongs to the axis. As 2 directions are mapped to an axis
 226  * this function returns the one which points to south,
 227  * either south-west (on X axis) or south-east (on Y axis)
 228  *
 229  * @param a The axis
 230  * @return The direction pointed to south
 231  */
 232 inline DiagDirection AxisToDiagDir(Axis a)
 233 {
 234         assert(IsValidAxis(a));
 235         return (DiagDirection)(2 - a);
 236 }
 237
 238 /**
 239  * Converts an Axis to a Direction
 240  *
 241  * This function returns the Direction which
 242  * belongs to the axis. As 2 directions are mapped to an axis
 243  * this function returns the one which points to south,
 244  * either south-west (on X axis) or south-east (on Y axis)
 245  *
 246  * @param a The axis
 247  * @return The direction pointed to south
 248  */
 249 inline Direction AxisToDirection(Axis a)
 250 {
 251         assert(IsValidAxis(a));
 252         return (Direction)(5 - 2 * a);
 253 }
 254
 255 /**
 256  * Convert an axis and a flag for north/south into a DiagDirection
 257  * @param xy axis to convert
 258  * @param ns north -> 0, south -> 1
 259  * @return the desired DiagDirection
 260  */
 261 inline DiagDirection XYNSToDiagDir(Axis xy, uint ns)
 262 {
 263         assert(IsValidAxis(xy));
 264         return (DiagDirection)(xy * 3 ^ ns * 2);
 265 }
 266
 267 /**
 268  * Checks if a given Direction is diagonal.
 269  *
 270  * @param dir The given direction.
 271  * @return True if the direction is diagonal.
 272  */
 273 inline bool IsDiagonalDirection(Direction dir)
 274 {
 275         assert(IsValidDirection(dir));
 276         return (dir & 1) != 0;
 277 }
 278
 279 #endif /* DIRECTION_FUNC_H */