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.
22 #include "basic_macros.h"
23 #include "../irrlichttypes.h"
24 #include "../irr_v2d.h"
25 #include "../irr_v3d.h"
26 #include "../irr_aabb3d.h"
28 #define rangelim(d, min, max) ((d) < (min) ? (min) : ((d) > (max) ? (max) : (d)))
29 #define myfloor(x) ((x) < 0.0 ? (int)(x) - 1 : (int)(x))
30 // The naive swap performs better than the xor version
31 #define SWAP(t, x, y) do { \
38 inline s16 getContainerPos(s16 p, s16 d)
40 return (p >= 0 ? p : p - d + 1) / d;
43 inline v2s16 getContainerPos(v2s16 p, s16 d)
46 getContainerPos(p.X, d),
47 getContainerPos(p.Y, d)
51 inline v3s16 getContainerPos(v3s16 p, s16 d)
54 getContainerPos(p.X, d),
55 getContainerPos(p.Y, d),
56 getContainerPos(p.Z, d)
60 inline v2s16 getContainerPos(v2s16 p, v2s16 d)
63 getContainerPos(p.X, d.X),
64 getContainerPos(p.Y, d.Y)
68 inline v3s16 getContainerPos(v3s16 p, v3s16 d)
71 getContainerPos(p.X, d.X),
72 getContainerPos(p.Y, d.Y),
73 getContainerPos(p.Z, d.Z)
77 inline void getContainerPosWithOffset(s16 p, s16 d, s16 &container, s16 &offset)
79 container = (p >= 0 ? p : p - d + 1) / d;
83 inline void getContainerPosWithOffset(const v2s16 &p, s16 d, v2s16 &container, v2s16 &offset)
85 getContainerPosWithOffset(p.X, d, container.X, offset.X);
86 getContainerPosWithOffset(p.Y, d, container.Y, offset.Y);
89 inline void getContainerPosWithOffset(const v3s16 &p, s16 d, v3s16 &container, v3s16 &offset)
91 getContainerPosWithOffset(p.X, d, container.X, offset.X);
92 getContainerPosWithOffset(p.Y, d, container.Y, offset.Y);
93 getContainerPosWithOffset(p.Z, d, container.Z, offset.Z);
97 inline bool isInArea(v3s16 p, s16 d)
100 p.X >= 0 && p.X < d &&
101 p.Y >= 0 && p.Y < d &&
106 inline bool isInArea(v2s16 p, s16 d)
109 p.X >= 0 && p.X < d &&
114 inline bool isInArea(v3s16 p, v3s16 d)
117 p.X >= 0 && p.X < d.X &&
118 p.Y >= 0 && p.Y < d.Y &&
119 p.Z >= 0 && p.Z < d.Z
123 inline void sortBoxVerticies(v3s16 &p1, v3s16 &p2) {
125 SWAP(s16, p1.X, p2.X);
127 SWAP(s16, p1.Y, p2.Y);
129 SWAP(s16, p1.Z, p2.Z);
132 inline v3s16 componentwise_min(const v3s16 &a, const v3s16 &b)
134 return v3s16(MYMIN(a.X, b.X), MYMIN(a.Y, b.Y), MYMIN(a.Z, b.Z));
137 inline v3s16 componentwise_max(const v3s16 &a, const v3s16 &b)
139 return v3s16(MYMAX(a.X, b.X), MYMAX(a.Y, b.Y), MYMAX(a.Z, b.Z));
143 /** Returns \p f wrapped to the range [-360, 360]
145 * See test.cpp for example cases.
147 * \note This is also used in cases where degrees wrapped to the range [0, 360]
148 * is innapropriate (e.g. pitch needs negative values)
150 * \internal functionally equivalent -- although precision may vary slightly --
151 * to fmodf((f), 360.0f) however empirical tests indicate that this approach is
154 inline float modulo360f(float f)
169 fraction = f - whole;
172 return sign * (whole + fraction);
176 /** Returns \p f wrapped to the range [0, 360]
178 inline float wrapDegrees_0_360(float f)
180 float value = modulo360f(f);
181 return value < 0 ? value + 360 : value;
185 /** Returns \p f wrapped to the range [-180, 180]
187 inline float wrapDegrees_180(float f)
189 float value = modulo360f(f + 180);
196 Pseudo-random (VC++ rand() sucks)
198 #define MYRAND_RANGE 0xffffffff
200 void mysrand(unsigned int seed);
201 void myrand_bytes(void *out, size_t len);
202 int myrand_range(int min, int max);
205 Miscellaneous functions
208 inline u32 get_bits(u32 x, u32 pos, u32 len)
210 u32 mask = (1 << len) - 1;
211 return (x >> pos) & mask;
214 inline void set_bits(u32 *x, u32 pos, u32 len, u32 val)
216 u32 mask = (1 << len) - 1;
217 *x &= ~(mask << pos);
218 *x |= (val & mask) << pos;
221 inline u32 calc_parity(u32 v)
227 return (0x6996 >> v) & 1;
230 u64 murmur_hash_64_ua(const void *key, int len, unsigned int seed);
232 bool isBlockInSight(v3s16 blockpos_b, v3f camera_pos, v3f camera_dir,
233 f32 camera_fov, f32 range, f32 *distance_ptr=NULL);
236 Returns nearest 32-bit integer for given floating point number.
237 <cmath> and <math.h> in VC++ don't provide round().
239 inline s32 myround(f32 f)
241 return (s32)(f < 0.f ? (f - 0.5f) : (f + 0.5f));
245 Returns integer position of node in given floating point position
247 inline v3s16 floatToInt(v3f p, f32 d)
250 (p.X + (p.X > 0 ? d / 2 : -d / 2)) / d,
251 (p.Y + (p.Y > 0 ? d / 2 : -d / 2)) / d,
252 (p.Z + (p.Z > 0 ? d / 2 : -d / 2)) / d);
256 Returns floating point position of node in given integer position
258 inline v3f intToFloat(v3s16 p, f32 d)
267 // Random helper. Usually d=BS
268 inline aabb3f getNodeBox(v3s16 p, float d)
271 (float)p.X * d - 0.5 * d,
272 (float)p.Y * d - 0.5 * d,
273 (float)p.Z * d - 0.5 * d,
274 (float)p.X * d + 0.5 * d,
275 (float)p.Y * d + 0.5 * d,
276 (float)p.Z * d + 0.5 * d
281 class IntervalLimiter
286 dtime: time from last call to this method
287 wanted_interval: interval wanted
289 true: action should be skipped
290 false: action should be done
292 bool step(float dtime, float wanted_interval)
294 m_accumulator += dtime;
295 if (m_accumulator < wanted_interval)
297 m_accumulator -= wanted_interval;
302 float m_accumulator = 0.0f;
307 Splits a list into "pages". For example, the list [1,2,3,4,5] split
308 into two pages would be [1,2,3],[4,5]. This function computes the
309 minimum and maximum indices of a single page.
311 length: Length of the list that should be split
312 page: Page number, 1 <= page <= pagecount
313 pagecount: The number of pages, >= 1
314 minindex: Receives the minimum index (inclusive).
315 maxindex: Receives the maximum index (exclusive).
317 Ensures 0 <= minindex <= maxindex <= length.
319 inline void paging(u32 length, u32 page, u32 pagecount, u32 &minindex, u32 &maxindex)
321 if (length < 1 || pagecount < 1 || page < 1 || page > pagecount) {
322 // Special cases or invalid parameters
323 minindex = maxindex = 0;
324 } else if(pagecount <= length) {
325 // Less pages than entries in the list:
326 // Each page contains at least one entry
327 minindex = (length * (page-1) + (pagecount-1)) / pagecount;
328 maxindex = (length * page + (pagecount-1)) / pagecount;
330 // More pages than entries in the list:
331 // Make sure the empty pages are at the end
342 inline float cycle_shift(float value, float by = 0, float max = 1)
344 if (value + by < 0) return value + by + max;
345 if (value + by > max) return value + by - max;
349 inline bool is_power_of_two(u32 n)
351 return n != 0 && (n & (n - 1)) == 0;
354 // Compute next-higher power of 2 efficiently, e.g. for power-of-2 texture sizes.
355 // Public Domain: https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
356 inline u32 npot2(u32 orig) {