src/direction_func.h

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