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"
26 #include "irr_aabb3d.h"
29 #define rangelim(d, min, max) ((d) < (min) ? (min) : ((d) > (max) ? (max) : (d)))
30 #define myfloor(x) ((x) < 0.0 ? (int)(x) - 1 : (int)(x))
31 // The naive swap performs better than the xor version
32 #define SWAP(t, x, y) do { \
39 inline s16 getContainerPos(s16 p, s16 d)
41 return (p >= 0 ? p : p - d + 1) / d;
44 inline v2s16 getContainerPos(v2s16 p, s16 d)
47 getContainerPos(p.X, d),
48 getContainerPos(p.Y, d)
52 inline v3s16 getContainerPos(v3s16 p, s16 d)
55 getContainerPos(p.X, d),
56 getContainerPos(p.Y, d),
57 getContainerPos(p.Z, d)
61 inline v2s16 getContainerPos(v2s16 p, v2s16 d)
64 getContainerPos(p.X, d.X),
65 getContainerPos(p.Y, d.Y)
69 inline v3s16 getContainerPos(v3s16 p, v3s16 d)
72 getContainerPos(p.X, d.X),
73 getContainerPos(p.Y, d.Y),
74 getContainerPos(p.Z, d.Z)
78 inline void getContainerPosWithOffset(s16 p, s16 d, s16 &container, s16 &offset)
80 container = (p >= 0 ? p : p - d + 1) / d;
84 inline void getContainerPosWithOffset(const v2s16 &p, s16 d, v2s16 &container, v2s16 &offset)
86 getContainerPosWithOffset(p.X, d, container.X, offset.X);
87 getContainerPosWithOffset(p.Y, d, container.Y, offset.Y);
90 inline void getContainerPosWithOffset(const v3s16 &p, s16 d, v3s16 &container, v3s16 &offset)
92 getContainerPosWithOffset(p.X, d, container.X, offset.X);
93 getContainerPosWithOffset(p.Y, d, container.Y, offset.Y);
94 getContainerPosWithOffset(p.Z, d, container.Z, offset.Z);
98 inline bool isInArea(v3s16 p, s16 d)
101 p.X >= 0 && p.X < d &&
102 p.Y >= 0 && p.Y < d &&
107 inline bool isInArea(v2s16 p, s16 d)
110 p.X >= 0 && p.X < d &&
115 inline bool isInArea(v3s16 p, v3s16 d)
118 p.X >= 0 && p.X < d.X &&
119 p.Y >= 0 && p.Y < d.Y &&
120 p.Z >= 0 && p.Z < d.Z
124 inline void sortBoxVerticies(v3s16 &p1, v3s16 &p2) {
126 SWAP(s16, p1.X, p2.X);
128 SWAP(s16, p1.Y, p2.Y);
130 SWAP(s16, p1.Z, p2.Z);
133 inline v3s16 componentwise_min(const v3s16 &a, const v3s16 &b)
135 return v3s16(MYMIN(a.X, b.X), MYMIN(a.Y, b.Y), MYMIN(a.Z, b.Z));
138 inline v3s16 componentwise_max(const v3s16 &a, const v3s16 &b)
140 return v3s16(MYMAX(a.X, b.X), MYMAX(a.Y, b.Y), MYMAX(a.Z, b.Z));
144 /** Returns \p f wrapped to the range [-360, 360]
146 * See test.cpp for example cases.
148 * \note This is also used in cases where degrees wrapped to the range [0, 360]
149 * is innapropriate (e.g. pitch needs negative values)
151 * \internal functionally equivalent -- although precision may vary slightly --
152 * to fmodf((f), 360.0f) however empirical tests indicate that this approach is
155 inline float modulo360f(float f)
170 fraction = f - whole;
173 return sign * (whole + fraction);
177 /** Returns \p f wrapped to the range [0, 360]
179 inline float wrapDegrees_0_360(float f)
181 float value = modulo360f(f);
182 return value < 0 ? value + 360 : value;
186 /** Returns \p v3f wrapped to the range [0, 360]
188 inline v3f wrapDegrees_0_360_v3f(v3f v)
191 value_v3f.X = modulo360f(v.X);
192 value_v3f.Y = modulo360f(v.Y);
193 value_v3f.Z = modulo360f(v.Z);
195 // Now that values are wrapped, use to get values for certain ranges
196 value_v3f.X = value_v3f.X < 0 ? value_v3f.X + 360 : value_v3f.X;
197 value_v3f.Y = value_v3f.Y < 0 ? value_v3f.Y + 360 : value_v3f.Y;
198 value_v3f.Z = value_v3f.Z < 0 ? value_v3f.Z + 360 : value_v3f.Z;
203 /** Returns \p f wrapped to the range [-180, 180]
205 inline float wrapDegrees_180(float f)
207 float value = modulo360f(f + 180);
214 Pseudo-random (VC++ rand() sucks)
216 #define MYRAND_RANGE 0xffffffff
218 void mysrand(unsigned int seed);
219 void myrand_bytes(void *out, size_t len);
220 int myrand_range(int min, int max);
223 Miscellaneous functions
226 inline u32 get_bits(u32 x, u32 pos, u32 len)
228 u32 mask = (1 << len) - 1;
229 return (x >> pos) & mask;
232 inline void set_bits(u32 *x, u32 pos, u32 len, u32 val)
234 u32 mask = (1 << len) - 1;
235 *x &= ~(mask << pos);
236 *x |= (val & mask) << pos;
239 inline u32 calc_parity(u32 v)
245 return (0x6996 >> v) & 1;
248 u64 murmur_hash_64_ua(const void *key, int len, unsigned int seed);
250 bool isBlockInSight(v3s16 blockpos_b, v3f camera_pos, v3f camera_dir,
251 f32 camera_fov, f32 range, f32 *distance_ptr=NULL);
253 s16 adjustDist(s16 dist, float zoom_fov);
256 Returns nearest 32-bit integer for given floating point number.
257 <cmath> and <math.h> in VC++ don't provide round().
259 inline s32 myround(f32 f)
261 return (s32)(f < 0.f ? (f - 0.5f) : (f + 0.5f));
264 inline constexpr f32 sqr(f32 f)
270 Returns integer position of node in given floating point position
272 inline v3s16 floatToInt(v3f p, f32 d)
275 (p.X + (p.X > 0 ? d / 2 : -d / 2)) / d,
276 (p.Y + (p.Y > 0 ? d / 2 : -d / 2)) / d,
277 (p.Z + (p.Z > 0 ? d / 2 : -d / 2)) / d);
281 Returns integer position of node in given double precision position
283 inline v3s16 doubleToInt(v3d p, double d)
286 (p.X + (p.X > 0 ? d / 2 : -d / 2)) / d,
287 (p.Y + (p.Y > 0 ? d / 2 : -d / 2)) / d,
288 (p.Z + (p.Z > 0 ? d / 2 : -d / 2)) / d);
292 Returns floating point position of node in given integer position
294 inline v3f intToFloat(v3s16 p, f32 d)
303 // Random helper. Usually d=BS
304 inline aabb3f getNodeBox(v3s16 p, float d)
307 (float)p.X * d - 0.5f * d,
308 (float)p.Y * d - 0.5f * d,
309 (float)p.Z * d - 0.5f * d,
310 (float)p.X * d + 0.5f * d,
311 (float)p.Y * d + 0.5f * d,
312 (float)p.Z * d + 0.5f * d
317 class IntervalLimiter
320 IntervalLimiter() = default;
323 dtime: time from last call to this method
324 wanted_interval: interval wanted
326 true: action should be skipped
327 false: action should be done
329 bool step(float dtime, float wanted_interval)
331 m_accumulator += dtime;
332 if (m_accumulator < wanted_interval)
334 m_accumulator -= wanted_interval;
339 float m_accumulator = 0.0f;
344 Splits a list into "pages". For example, the list [1,2,3,4,5] split
345 into two pages would be [1,2,3],[4,5]. This function computes the
346 minimum and maximum indices of a single page.
348 length: Length of the list that should be split
349 page: Page number, 1 <= page <= pagecount
350 pagecount: The number of pages, >= 1
351 minindex: Receives the minimum index (inclusive).
352 maxindex: Receives the maximum index (exclusive).
354 Ensures 0 <= minindex <= maxindex <= length.
356 inline void paging(u32 length, u32 page, u32 pagecount, u32 &minindex, u32 &maxindex)
358 if (length < 1 || pagecount < 1 || page < 1 || page > pagecount) {
359 // Special cases or invalid parameters
360 minindex = maxindex = 0;
361 } else if(pagecount <= length) {
362 // Less pages than entries in the list:
363 // Each page contains at least one entry
364 minindex = (length * (page-1) + (pagecount-1)) / pagecount;
365 maxindex = (length * page + (pagecount-1)) / pagecount;
367 // More pages than entries in the list:
368 // Make sure the empty pages are at the end
379 inline float cycle_shift(float value, float by = 0, float max = 1)
381 if (value + by < 0) return value + by + max;
382 if (value + by > max) return value + by - max;
386 inline bool is_power_of_two(u32 n)
388 return n != 0 && (n & (n - 1)) == 0;
391 // Compute next-higher power of 2 efficiently, e.g. for power-of-2 texture sizes.
392 // Public Domain: https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
393 inline u32 npot2(u32 orig) {
403 // Gradual steps towards the target value in a wrapped (circular) system
404 // using the shorter of both ways
406 inline void wrappedApproachShortest(T ¤t, const T target, const T stepsize,
409 T delta = target - current;
413 if (delta > stepsize && maximum - delta > stepsize) {
414 current += (delta < maximum / 2) ? stepsize : -stepsize;
415 if (current >= maximum)
422 void setPitchYawRollRad(core::matrix4 &m, const v3f &rot);
424 inline void setPitchYawRoll(core::matrix4 &m, const v3f &rot)
426 setPitchYawRollRad(m, rot * core::DEGTORAD64);
429 v3f getPitchYawRollRad(const core::matrix4 &m);
431 inline v3f getPitchYawRoll(const core::matrix4 &m)
433 return getPitchYawRollRad(m) * core::RADTODEG64;