3 Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
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.
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.
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.
20 #ifndef UTIL_NUMERIC_HEADER
21 #define UTIL_NUMERIC_HEADER
23 #include "../irrlichttypes.h"
24 #include "../irr_v2d.h"
25 #include "../irr_v3d.h"
26 #include "../irr_aabb3d.h"
27 #include "../threading/mutex.h"
35 * This class permits to cache getFacePosition call results
36 * This reduces CPU usage and vector calls
38 class FacePositionCache
41 static std::vector<v3s16> getFacePositions(u16 d);
43 static void generateFacePosition(u16 d);
44 static std::map<u16, std::vector<v3s16> > m_cache;
45 static Mutex m_cache_mutex;
48 class IndentationRaiser
51 IndentationRaiser(u16 *indentation)
53 m_indentation = indentation;
64 inline s16 getContainerPos(s16 p, s16 d)
66 return (p>=0 ? p : p-d+1) / d;
69 inline v2s16 getContainerPos(v2s16 p, s16 d)
72 getContainerPos(p.X, d),
73 getContainerPos(p.Y, d)
77 inline v3s16 getContainerPos(v3s16 p, s16 d)
80 getContainerPos(p.X, d),
81 getContainerPos(p.Y, d),
82 getContainerPos(p.Z, d)
86 inline v2s16 getContainerPos(v2s16 p, v2s16 d)
89 getContainerPos(p.X, d.X),
90 getContainerPos(p.Y, d.Y)
94 inline v3s16 getContainerPos(v3s16 p, v3s16 d)
97 getContainerPos(p.X, d.X),
98 getContainerPos(p.Y, d.Y),
99 getContainerPos(p.Z, d.Z)
103 inline void getContainerPosWithOffset(s16 p, s16 d, s16 &container, s16 &offset)
105 container = (p >= 0 ? p : p - d + 1) / d;
106 offset = p & (d - 1);
109 inline void getContainerPosWithOffset(const v2s16 &p, s16 d, v2s16 &container, v2s16 &offset)
111 getContainerPosWithOffset(p.X, d, container.X, offset.X);
112 getContainerPosWithOffset(p.Y, d, container.Y, offset.Y);
115 inline void getContainerPosWithOffset(const v3s16 &p, s16 d, v3s16 &container, v3s16 &offset)
117 getContainerPosWithOffset(p.X, d, container.X, offset.X);
118 getContainerPosWithOffset(p.Y, d, container.Y, offset.Y);
119 getContainerPosWithOffset(p.Z, d, container.Z, offset.Z);
123 inline bool isInArea(v3s16 p, s16 d)
126 p.X >= 0 && p.X < d &&
127 p.Y >= 0 && p.Y < d &&
132 inline bool isInArea(v2s16 p, s16 d)
135 p.X >= 0 && p.X < d &&
140 inline bool isInArea(v3s16 p, v3s16 d)
143 p.X >= 0 && p.X < d.X &&
144 p.Y >= 0 && p.Y < d.Y &&
145 p.Z >= 0 && p.Z < d.Z
149 #define rangelim(d, min, max) ((d) < (min) ? (min) : ((d)>(max)?(max):(d)))
150 #define myfloor(x) ((x) > 0.0 ? (int)(x) : (int)(x) - 1)
152 inline v3s16 arealim(v3s16 p, s16 d)
169 #define ARRLEN(x) (sizeof(x) / sizeof((x)[0]))
170 #define CONTAINS(c, v) (std::find((c).begin(), (c).end(), (v)) != (c).end())
172 // The naive swap performs better than the xor version
173 #define SWAP(t, x, y) do { \
179 inline void sortBoxVerticies(v3s16 &p1, v3s16 &p2) {
181 SWAP(s16, p1.X, p2.X);
183 SWAP(s16, p1.Y, p2.Y);
185 SWAP(s16, p1.Z, p2.Z);
189 /** Returns \p f wrapped to the range [-360, 360]
191 * See test.cpp for example cases.
193 * \note This is also used in cases where degrees wrapped to the range [0, 360]
194 * is innapropriate (e.g. pitch needs negative values)
196 * \internal functionally equivalent -- although precision may vary slightly --
197 * to fmodf((f), 360.0f) however empirical tests indicate that this approach is
200 inline float modulo360f(float f)
215 fraction = f - whole;
218 return sign * (whole + fraction);
222 /** Returns \p f wrapped to the range [0, 360]
224 inline float wrapDegrees_0_360(float f)
226 float value = modulo360f(f);
227 return value < 0 ? value + 360 : value;
231 /** Returns \p f wrapped to the range [-180, 180]
233 inline float wrapDegrees_180(float f)
235 float value = modulo360f(f + 180);
242 Pseudo-random (VC++ rand() sucks)
244 #define MYRAND_RANGE 0xffffffff
246 void mysrand(unsigned int seed);
247 void myrand_bytes(void *out, size_t len);
248 int myrand_range(int min, int max);
251 Miscellaneous functions
254 inline u32 get_bits(u32 x, u32 pos, u32 len)
256 u32 mask = (1 << len) - 1;
257 return (x >> pos) & mask;
260 inline void set_bits(u32 *x, u32 pos, u32 len, u32 val)
262 u32 mask = (1 << len) - 1;
263 *x &= ~(mask << pos);
264 *x |= (val & mask) << pos;
267 inline u32 calc_parity(u32 v)
273 return (0x6996 >> v) & 1;
276 u64 murmur_hash_64_ua(const void *key, int len, unsigned int seed);
278 bool isBlockInSight(v3s16 blockpos_b, v3f camera_pos, v3f camera_dir,
279 f32 camera_fov, f32 range, f32 *distance_ptr=NULL);
284 #define MYMIN(a,b) ((a)<(b)?(a):(b))
285 #define MYMAX(a,b) ((a)>(b)?(a):(b))
288 Returns nearest 32-bit integer for given floating point number.
289 <cmath> and <math.h> in VC++ don't provide round().
291 inline s32 myround(f32 f)
293 return (s32)(f < 0.f ? (f - 0.5f) : (f + 0.5f));
297 Returns integer position of node in given floating point position
299 inline v3s16 floatToInt(v3f p, f32 d)
302 (p.X + (p.X>0 ? d/2 : -d/2))/d,
303 (p.Y + (p.Y>0 ? d/2 : -d/2))/d,
304 (p.Z + (p.Z>0 ? d/2 : -d/2))/d);
309 Returns floating point position of node in given integer position
311 inline v3f intToFloat(v3s16 p, f32 d)
321 // Random helper. Usually d=BS
322 inline core::aabbox3d<f32> getNodeBox(v3s16 p, float d)
324 return core::aabbox3d<f32>(
325 (float)p.X * d - 0.5*d,
326 (float)p.Y * d - 0.5*d,
327 (float)p.Z * d - 0.5*d,
328 (float)p.X * d + 0.5*d,
329 (float)p.Y * d + 0.5*d,
330 (float)p.Z * d + 0.5*d
334 class IntervalLimiter
342 dtime: time from last call to this method
343 wanted_interval: interval wanted
345 true: action should be skipped
346 false: action should be done
348 bool step(float dtime, float wanted_interval)
350 m_accumulator += dtime;
351 if(m_accumulator < wanted_interval)
353 m_accumulator -= wanted_interval;
361 Splits a list into "pages". For example, the list [1,2,3,4,5] split
362 into two pages would be [1,2,3],[4,5]. This function computes the
363 minimum and maximum indices of a single page.
365 length: Length of the list that should be split
366 page: Page number, 1 <= page <= pagecount
367 pagecount: The number of pages, >= 1
368 minindex: Receives the minimum index (inclusive).
369 maxindex: Receives the maximum index (exclusive).
371 Ensures 0 <= minindex <= maxindex <= length.
373 inline void paging(u32 length, u32 page, u32 pagecount, u32 &minindex, u32 &maxindex)
375 if(length < 1 || pagecount < 1 || page < 1 || page > pagecount)
377 // Special cases or invalid parameters
378 minindex = maxindex = 0;
380 else if(pagecount <= length)
382 // Less pages than entries in the list:
383 // Each page contains at least one entry
384 minindex = (length * (page-1) + (pagecount-1)) / pagecount;
385 maxindex = (length * page + (pagecount-1)) / pagecount;
389 // More pages than entries in the list:
390 // Make sure the empty pages are at the end
404 inline float cycle_shift(float value, float by = 0, float max = 1)
406 if (value + by < 0) return max + by + value;
407 if (value + by > max) return value + by - max;
411 inline bool is_power_of_two(u32 n)
413 return n != 0 && (n & (n-1)) == 0;
416 // Compute next-higher power of 2 efficiently, e.g. for power-of-2 texture sizes.
417 // Public Domain: https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
418 inline u32 npot2(u32 orig) {