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