]> git.lizzy.rs Git - dragonfireclient.git/blob - src/util/numeric.h
Omnicleanup: header cleanup, add ModApiUtil shared between game and mainmenu
[dragonfireclient.git] / src / util / numeric.h
1 /*
2 Minetest
3 Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU Lesser General Public License as published by
7 the Free Software Foundation; either version 2.1 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 GNU Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public License along
16 with this program; if not, write to the Free Software Foundation, Inc.,
17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 */
19
20 #ifndef UTIL_NUMERIC_HEADER
21 #define UTIL_NUMERIC_HEADER
22
23 #include "../irrlichttypes.h"
24 #include "../irr_v2d.h"
25 #include "../irr_v3d.h"
26 #include "../irr_aabb3d.h"
27 #include <list>
28
29 // Calculate the borders of a "d-radius" cube
30 void getFacePositions(std::list<v3s16> &list, u16 d);
31
32 class IndentationRaiser
33 {
34 public:
35         IndentationRaiser(u16 *indentation)
36         {
37                 m_indentation = indentation;
38                 (*m_indentation)++;
39         }
40         ~IndentationRaiser()
41         {
42                 (*m_indentation)--;
43         }
44 private:
45         u16 *m_indentation;
46 };
47
48 inline s16 getContainerPos(s16 p, s16 d)
49 {
50         return (p>=0 ? p : p-d+1) / d;
51 }
52
53 inline v2s16 getContainerPos(v2s16 p, s16 d)
54 {
55         return v2s16(
56                 getContainerPos(p.X, d),
57                 getContainerPos(p.Y, d)
58         );
59 }
60
61 inline v3s16 getContainerPos(v3s16 p, s16 d)
62 {
63         return v3s16(
64                 getContainerPos(p.X, d),
65                 getContainerPos(p.Y, d),
66                 getContainerPos(p.Z, d)
67         );
68 }
69
70 inline v2s16 getContainerPos(v2s16 p, v2s16 d)
71 {
72         return v2s16(
73                 getContainerPos(p.X, d.X),
74                 getContainerPos(p.Y, d.Y)
75         );
76 }
77
78 inline v3s16 getContainerPos(v3s16 p, v3s16 d)
79 {
80         return v3s16(
81                 getContainerPos(p.X, d.X),
82                 getContainerPos(p.Y, d.Y),
83                 getContainerPos(p.Z, d.Z)
84         );
85 }
86
87 inline bool isInArea(v3s16 p, s16 d)
88 {
89         return (
90                 p.X >= 0 && p.X < d &&
91                 p.Y >= 0 && p.Y < d &&
92                 p.Z >= 0 && p.Z < d
93         );
94 }
95
96 inline bool isInArea(v2s16 p, s16 d)
97 {
98         return (
99                 p.X >= 0 && p.X < d &&
100                 p.Y >= 0 && p.Y < d
101         );
102 }
103
104 inline bool isInArea(v3s16 p, v3s16 d)
105 {
106         return (
107                 p.X >= 0 && p.X < d.X &&
108                 p.Y >= 0 && p.Y < d.Y &&
109                 p.Z >= 0 && p.Z < d.Z
110         );
111 }
112
113 inline s16 rangelim(s16 i, s16 max)
114 {
115         if(i < 0)
116                 return 0;
117         if(i > max)
118                 return max;
119         return i;
120 }
121
122 #define rangelim(d, min, max) ((d) < (min) ? (min) : ((d)>(max)?(max):(d)))
123 #define myfloor(x) ((x) > 0.0 ? (int)(x) : (int)(x) - 1)
124
125 inline v3s16 arealim(v3s16 p, s16 d)
126 {
127         if(p.X < 0)
128                 p.X = 0;
129         if(p.Y < 0)
130                 p.Y = 0;
131         if(p.Z < 0)
132                 p.Z = 0;
133         if(p.X > d-1)
134                 p.X = d-1;
135         if(p.Y > d-1)
136                 p.Y = d-1;
137         if(p.Z > d-1)
138                 p.Z = d-1;
139         return p;
140 }
141
142 // The naive swap performs better than the xor version
143 #define SWAP(t, x, y) do { \
144         t temp = x;            \
145         x = y;                 \
146         y = temp;              \
147 } while (0)
148
149 inline void sortBoxVerticies(v3s16 &p1, v3s16 &p2) {
150         if (p1.X > p2.X)
151                 SWAP(s16, p1.X, p2.X);
152         if (p1.Y > p2.Y)
153                 SWAP(s16, p1.Y, p2.Y);
154         if (p1.Z > p2.Z)
155                 SWAP(s16, p1.Z, p2.Z);
156 }
157
158
159 /*
160         See test.cpp for example cases.
161         wraps degrees to the range of -360...360
162         NOTE: Wrapping to 0...360 is not used because pitch needs negative values.
163 */
164 inline float wrapDegrees(float f)
165 {
166         // Take examples of f=10, f=720.5, f=-0.5, f=-360.5
167         // This results in
168         // 10, 720, -1, -361
169         int i = floor(f);
170         // 0, 2, 0, -1
171         int l = i / 360;
172         // NOTE: This would be used for wrapping to 0...360
173         // 0, 2, -1, -2
174         /*if(i < 0)
175                 l -= 1;*/
176         // 0, 720, 0, -360
177         int k = l * 360;
178         // 10, 0.5, -0.5, -0.5
179         f -= float(k);
180         return f;
181 }
182
183 /* Wrap to 0...360 */
184 inline float wrapDegrees_0_360(float f)
185 {
186         // Take examples of f=10, f=720.5, f=-0.5, f=-360.5
187         // This results in
188         // 10, 720, -1, -361
189         int i = floor(f);
190         // 0, 2, 0, -1
191         int l = i / 360;
192         // Wrap to 0...360
193         // 0, 2, -1, -2
194         if(i < 0)
195                 l -= 1;
196         // 0, 720, 0, -360
197         int k = l * 360;
198         // 10, 0.5, -0.5, -0.5
199         f -= float(k);
200         return f;
201 }
202
203 /* Wrap to -180...180 */
204 inline float wrapDegrees_180(float f)
205 {
206         f += 180;
207         f = wrapDegrees_0_360(f);
208         f -= 180;
209         return f;
210 }
211
212 /*
213         Pseudo-random (VC++ rand() sucks)
214 */
215 int myrand(void);
216 void mysrand(unsigned seed);
217 #define MYRAND_MAX 32767
218
219 int myrand_range(int min, int max);
220
221 /*
222         Miscellaneous functions
223 */
224
225 bool isBlockInSight(v3s16 blockpos_b, v3f camera_pos, v3f camera_dir,
226                 f32 camera_fov, f32 range, f32 *distance_ptr=NULL);
227
228 /*
229         Some helper stuff
230 */
231 #define MYMIN(a,b) ((a)<(b)?(a):(b))
232 #define MYMAX(a,b) ((a)>(b)?(a):(b))
233
234 /*
235         Returns nearest 32-bit integer for given floating point number.
236         <cmath> and <math.h> in VC++ don't provide round().
237 */
238 inline s32 myround(f32 f)
239 {
240         return floor(f + 0.5);
241 }
242
243 /*
244         Returns integer position of node in given floating point position
245 */
246 inline v3s16 floatToInt(v3f p, f32 d)
247 {
248         v3s16 p2(
249                 (p.X + (p.X>0 ? d/2 : -d/2))/d,
250                 (p.Y + (p.Y>0 ? d/2 : -d/2))/d,
251                 (p.Z + (p.Z>0 ? d/2 : -d/2))/d);
252         return p2;
253 }
254
255 /*
256         Returns floating point position of node in given integer position
257 */
258 inline v3f intToFloat(v3s16 p, f32 d)
259 {
260         v3f p2(
261                 (f32)p.X * d,
262                 (f32)p.Y * d,
263                 (f32)p.Z * d
264         );
265         return p2;
266 }
267
268 // Random helper. Usually d=BS
269 inline core::aabbox3d<f32> getNodeBox(v3s16 p, float d)
270 {
271         return core::aabbox3d<f32>(
272                 (float)p.X * d - 0.5*d,
273                 (float)p.Y * d - 0.5*d,
274                 (float)p.Z * d - 0.5*d,
275                 (float)p.X * d + 0.5*d,
276                 (float)p.Y * d + 0.5*d,
277                 (float)p.Z * d + 0.5*d
278         );
279 }
280
281 class IntervalLimiter
282 {
283 public:
284         IntervalLimiter():
285                 m_accumulator(0)
286         {
287         }
288         /*
289                 dtime: time from last call to this method
290                 wanted_interval: interval wanted
291                 return value:
292                         true: action should be skipped
293                         false: action should be done
294         */
295         bool step(float dtime, float wanted_interval)
296         {
297                 m_accumulator += dtime;
298                 if(m_accumulator < wanted_interval)
299                         return false;
300                 m_accumulator -= wanted_interval;
301                 return true;
302         }
303 protected:
304         float m_accumulator;
305 };
306
307 /*
308         Splits a list into "pages". For example, the list [1,2,3,4,5] split
309         into two pages would be [1,2,3],[4,5]. This function computes the
310         minimum and maximum indices of a single page.
311
312         length: Length of the list that should be split
313         page: Page number, 1 <= page <= pagecount
314         pagecount: The number of pages, >= 1
315         minindex: Receives the minimum index (inclusive).
316         maxindex: Receives the maximum index (exclusive).
317
318         Ensures 0 <= minindex <= maxindex <= length.
319 */
320 inline void paging(u32 length, u32 page, u32 pagecount, u32 &minindex, u32 &maxindex)
321 {
322         if(length < 1 || pagecount < 1 || page < 1 || page > pagecount)
323         {
324                 // Special cases or invalid parameters
325                 minindex = maxindex = 0;
326         }
327         else if(pagecount <= length)
328         {
329                 // Less pages than entries in the list:
330                 // Each page contains at least one entry
331                 minindex = (length * (page-1) + (pagecount-1)) / pagecount;
332                 maxindex = (length * page + (pagecount-1)) / pagecount;
333         }
334         else
335         {
336                 // More pages than entries in the list:
337                 // Make sure the empty pages are at the end
338                 if(page < length)
339                 {
340                         minindex = page-1;
341                         maxindex = page;
342                 }
343                 else
344                 {
345                         minindex = 0;
346                         maxindex = 0;
347                 }
348         }
349 }
350
351 inline float cycle_shift(float value, float by = 0, float max = 1)
352 {
353     if (value + by < 0) return max + by + value;
354     if (value + by > max) return value + by - max;
355     return value + by;
356 }
357
358 #endif
359