X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Futil%2Fnumeric.h;h=643c444409af64aca6ba094901ce4b6559914d41;hb=8f49358153637bb87f492e558a13cf9f23046e64;hp=3e82997bd98dca58bbafa715b4ddf4cb83a32159;hpb=c1b829077a3518f3a129eee11887b2358a53f20b;p=dragonfireclient.git diff --git a/src/util/numeric.h b/src/util/numeric.h index 3e82997bd..643c44440 100644 --- a/src/util/numeric.h +++ b/src/util/numeric.h @@ -20,15 +20,30 @@ with this program; if not, write to the Free Software Foundation, Inc., #ifndef UTIL_NUMERIC_HEADER #define UTIL_NUMERIC_HEADER +#include "../basicmacros.h" #include "../irrlichttypes.h" #include "../irr_v2d.h" #include "../irr_v3d.h" #include "../irr_aabb3d.h" -#include +#include "../threading/mutex.h" #include +#include +#include -// Calculate the borders of a "d-radius" cube -void getFacePositions(std::list &list, u16 d); + +/* + * This class permits to cache getFacePosition call results + * This reduces CPU usage and vector calls + */ +class FacePositionCache +{ +public: + static std::vector getFacePositions(u16 d); +private: + static void generateFacePosition(u16 d); + static std::map > m_cache; + static Mutex m_cache_mutex; +}; class IndentationRaiser { @@ -85,6 +100,26 @@ inline v3s16 getContainerPos(v3s16 p, v3s16 d) ); } +inline void getContainerPosWithOffset(s16 p, s16 d, s16 &container, s16 &offset) +{ + container = (p >= 0 ? p : p - d + 1) / d; + offset = p & (d - 1); +} + +inline void getContainerPosWithOffset(const v2s16 &p, s16 d, v2s16 &container, v2s16 &offset) +{ + getContainerPosWithOffset(p.X, d, container.X, offset.X); + getContainerPosWithOffset(p.Y, d, container.Y, offset.Y); +} + +inline void getContainerPosWithOffset(const v3s16 &p, s16 d, v3s16 &container, v3s16 &offset) +{ + getContainerPosWithOffset(p.X, d, container.X, offset.X); + getContainerPosWithOffset(p.Y, d, container.Y, offset.Y); + getContainerPosWithOffset(p.Z, d, container.Z, offset.Z); +} + + inline bool isInArea(v3s16 p, s16 d) { return ( @@ -111,15 +146,6 @@ inline bool isInArea(v3s16 p, v3s16 d) ); } -inline s16 rangelim(s16 i, s16 max) -{ - if(i < 0) - return 0; - if(i > max) - return max; - return i; -} - #define rangelim(d, min, max) ((d) < (min) ? (min) : ((d)>(max)?(max):(d))) #define myfloor(x) ((x) > 0.0 ? (int)(x) : (int)(x) - 1) @@ -157,88 +183,105 @@ inline void sortBoxVerticies(v3s16 &p1, v3s16 &p2) { } -/* - See test.cpp for example cases. - wraps degrees to the range of -360...360 - NOTE: Wrapping to 0...360 is not used because pitch needs negative values. -*/ -inline float wrapDegrees(float f) +/** Returns \p f wrapped to the range [-360, 360] + * + * See test.cpp for example cases. + * + * \note This is also used in cases where degrees wrapped to the range [0, 360] + * is innapropriate (e.g. pitch needs negative values) + * + * \internal functionally equivalent -- although precision may vary slightly -- + * to fmodf((f), 360.0f) however empirical tests indicate that this approach is + * faster. + */ +inline float modulo360f(float f) { - // Take examples of f=10, f=720.5, f=-0.5, f=-360.5 - // This results in - // 10, 720, -1, -361 - int i = floor(f); - // 0, 2, 0, -1 - int l = i / 360; - // NOTE: This would be used for wrapping to 0...360 - // 0, 2, -1, -2 - /*if(i < 0) - l -= 1;*/ - // 0, 720, 0, -360 - int k = l * 360; - // 10, 0.5, -0.5, -0.5 - f -= float(k); - return f; + int sign; + int whole; + float fraction; + + if (f < 0) { + f = -f; + sign = -1; + } else { + sign = 1; + } + + whole = f; + + fraction = f - whole; + whole %= 360; + + return sign * (whole + fraction); } -/* Wrap to 0...360 */ + +/** Returns \p f wrapped to the range [0, 360] + */ inline float wrapDegrees_0_360(float f) { - // Take examples of f=10, f=720.5, f=-0.5, f=-360.5 - // This results in - // 10, 720, -1, -361 - int i = floor(f); - // 0, 2, 0, -1 - int l = i / 360; - // Wrap to 0...360 - // 0, 2, -1, -2 - if(i < 0) - l -= 1; - // 0, 720, 0, -360 - int k = l * 360; - // 10, 0.5, -0.5, -0.5 - f -= float(k); - return f; + float value = modulo360f(f); + return value < 0 ? value + 360 : value; } -/* Wrap to -180...180 */ + +/** Returns \p f wrapped to the range [-180, 180] + */ inline float wrapDegrees_180(float f) { - f += 180; - f = wrapDegrees_0_360(f); - f -= 180; - return f; + float value = modulo360f(f + 180); + if (value < 0) + value += 360; + return value - 180; } /* Pseudo-random (VC++ rand() sucks) */ -int myrand(void); -void mysrand(unsigned seed); -#define MYRAND_MAX 32767 - +#define MYRAND_RANGE 0xffffffff +u32 myrand(); +void mysrand(unsigned int seed); +void myrand_bytes(void *out, size_t len); int myrand_range(int min, int max); /* Miscellaneous functions */ +inline u32 get_bits(u32 x, u32 pos, u32 len) +{ + u32 mask = (1 << len) - 1; + return (x >> pos) & mask; +} + +inline void set_bits(u32 *x, u32 pos, u32 len, u32 val) +{ + u32 mask = (1 << len) - 1; + *x &= ~(mask << pos); + *x |= (val & mask) << pos; +} + +inline u32 calc_parity(u32 v) +{ + v ^= v >> 16; + v ^= v >> 8; + v ^= v >> 4; + v &= 0xf; + return (0x6996 >> v) & 1; +} + +u64 murmur_hash_64_ua(const void *key, int len, unsigned int seed); + bool isBlockInSight(v3s16 blockpos_b, v3f camera_pos, v3f camera_dir, f32 camera_fov, f32 range, f32 *distance_ptr=NULL); -/* - Some helper stuff -*/ -#define MYMIN(a,b) ((a)<(b)?(a):(b)) -#define MYMAX(a,b) ((a)>(b)?(a):(b)) - /* Returns nearest 32-bit integer for given floating point number. and in VC++ don't provide round(). */ inline s32 myround(f32 f) { - return floor(f + 0.5); + return (s32)(f < 0.f ? (f - 0.5f) : (f + 0.5f)); } /* @@ -349,5 +392,28 @@ inline void paging(u32 length, u32 page, u32 pagecount, u32 &minindex, u32 &maxi } } -#endif +inline float cycle_shift(float value, float by = 0, float max = 1) +{ + if (value + by < 0) return max + by + value; + if (value + by > max) return value + by - max; + return value + by; +} +inline bool is_power_of_two(u32 n) +{ + return n != 0 && (n & (n-1)) == 0; +} + +// Compute next-higher power of 2 efficiently, e.g. for power-of-2 texture sizes. +// Public Domain: https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2 +inline u32 npot2(u32 orig) { + orig--; + orig |= orig >> 1; + orig |= orig >> 2; + orig |= orig >> 4; + orig |= orig >> 8; + orig |= orig >> 16; + return orig + 1; +} + +#endif