Allow rotating entity selectionboxes (#12379)

[minetest.git] / src / util / numeric.h

diff --git a/src/util/numeric.h b/src/util/numeric.h
index 3b1b85f64640adf4b1be8fb18db683908a1e1508..265046a63243c4769260e585d18df57ef627c2af 100644 (file)
--- a/src/util/numeric.h
+++ b/src/util/numeric.h
@@ -17,14 +17,16 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
-#ifndef UTIL_NUMERIC_HEADER
-#define UTIL_NUMERIC_HEADER
+#pragma once
 
 #include "basic_macros.h"
-#include "../irrlichttypes.h"
-#include "../irr_v2d.h"
-#include "../irr_v3d.h"
-#include "../irr_aabb3d.h"
+#include "constants.h"
+#include "irrlichttypes.h"
+#include "irr_v2d.h"
+#include "irr_v3d.h"
+#include "irr_aabb3d.h"
+#include "SColor.h"
+#include <matrix4.h>
 
 #define rangelim(d, min, max) ((d) < (min) ? (min) : ((d) > (max) ? (max) : (d)))
 #define myfloor(x) ((x) < 0.0 ? (int)(x) - 1 : (int)(x))
@@ -35,6 +37,9 @@ with this program; if not, write to the Free Software Foundation, Inc.,
        y = temp; \
 } while (0)
 
+// Maximum radius of a block.  The magic number is
+// sqrt(3.0) / 2.0 in literal form.
+static constexpr const f32 BLOCK_MAX_RADIUS = 0.866025403784f * MAP_BLOCKSIZE * BS;
 
 inline s16 getContainerPos(s16 p, s16 d)
 {
@@ -183,6 +188,23 @@ inline float wrapDegrees_0_360(float f)
 }
 
 
+/** Returns \p v3f wrapped to the range [0, 360]
+  */
+inline v3f wrapDegrees_0_360_v3f(v3f v)
+{
+       v3f value_v3f;
+       value_v3f.X = modulo360f(v.X);
+       value_v3f.Y = modulo360f(v.Y);
+       value_v3f.Z = modulo360f(v.Z);
+
+       // Now that values are wrapped, use to get values for certain ranges
+       value_v3f.X = value_v3f.X < 0 ? value_v3f.X + 360 : value_v3f.X;
+       value_v3f.Y = value_v3f.Y < 0 ? value_v3f.Y + 360 : value_v3f.Y;
+       value_v3f.Z = value_v3f.Z < 0 ? value_v3f.Z + 360 : value_v3f.Z;
+       return value_v3f;
+}
+
+
 /** Returns \p f wrapped to the range [-180, 180]
   */
 inline float wrapDegrees_180(float f)
@@ -201,6 +223,8 @@ u32 myrand();
 void mysrand(unsigned int seed);
 void myrand_bytes(void *out, size_t len);
 int myrand_range(int min, int max);
+float myrand_range(float min, float max);
+float myrand_float();
 
 /*
        Miscellaneous functions
@@ -233,6 +257,8 @@ 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);
 
+s16 adjustDist(s16 dist, float zoom_fov);
+
 /*
        Returns nearest 32-bit integer for given floating point number.
        <cmath> and <math.h> in VC++ don't provide round().
@@ -242,6 +268,11 @@ inline s32 myround(f32 f)
        return (s32)(f < 0.f ? (f - 0.5f) : (f + 0.5f));
 }
 
+inline constexpr f32 sqr(f32 f)
+{
+       return f * f;
+}
+
 /*
        Returns integer position of node in given floating point position
 */
@@ -253,6 +284,17 @@ inline v3s16 floatToInt(v3f p, f32 d)
                (p.Z + (p.Z > 0 ? d / 2 : -d / 2)) / d);
 }
 
+/*
+       Returns integer position of node in given double precision position
+ */
+inline v3s16 doubleToInt(v3d p, double d)
+{
+       return v3s16(
+               (p.X + (p.X > 0 ? d / 2 : -d / 2)) / d,
+               (p.Y + (p.Y > 0 ? d / 2 : -d / 2)) / d,
+               (p.Z + (p.Z > 0 ? d / 2 : -d / 2)) / d);
+}
+
 /*
        Returns floating point position of node in given integer position
 */
@@ -269,12 +311,12 @@ inline v3f intToFloat(v3s16 p, f32 d)
 inline aabb3f getNodeBox(v3s16 p, float d)
 {
        return aabb3f(
-               (float)p.X * d - 0.5 * d,
-               (float)p.Y * d - 0.5 * d,
-               (float)p.Z * d - 0.5 * d,
-               (float)p.X * d + 0.5 * d,
-               (float)p.Y * d + 0.5 * d,
-               (float)p.Z * d + 0.5 * d
+               (float)p.X * d - 0.5f * d,
+               (float)p.Y * d - 0.5f * d,
+               (float)p.Z * d - 0.5f * d,
+               (float)p.X * d + 0.5f * d,
+               (float)p.Y * d + 0.5f * d,
+               (float)p.Z * d + 0.5f * d
        );
 }
 
@@ -282,7 +324,8 @@ inline aabb3f getNodeBox(v3s16 p, float d)
 class IntervalLimiter
 {
 public:
-       IntervalLimiter() : m_accumulator(0) {}
+       IntervalLimiter() = default;
+
        /*
                dtime: time from last call to this method
                wanted_interval: interval wanted
@@ -300,7 +343,7 @@ class IntervalLimiter
        }
 
 private:
-       float m_accumulator;
+       float m_accumulator = 0.0f;
 };
 
 
@@ -364,4 +407,65 @@ inline u32 npot2(u32 orig) {
        return orig + 1;
 }
 
-#endif
+// Gradual steps towards the target value in a wrapped (circular) system
+// using the shorter of both ways
+template<typename T>
+inline void wrappedApproachShortest(T &current, const T target, const T stepsize,
+       const T maximum)
+{
+       T delta = target - current;
+       if (delta < 0)
+               delta += maximum;
+
+       if (delta > stepsize && maximum - delta > stepsize) {
+               current += (delta < maximum / 2) ? stepsize : -stepsize;
+               if (current >= maximum)
+                       current -= maximum;
+       } else {
+               current = target;
+       }
+}
+
+void setPitchYawRollRad(core::matrix4 &m, const v3f &rot);
+
+inline void setPitchYawRoll(core::matrix4 &m, const v3f &rot)
+{
+       setPitchYawRollRad(m, rot * core::DEGTORAD64);
+}
+
+v3f getPitchYawRollRad(const core::matrix4 &m);
+
+inline v3f getPitchYawRoll(const core::matrix4 &m)
+{
+       return getPitchYawRollRad(m) * core::RADTODEG64;
+}
+
+// Muliply the RGB value of a color linearly, and clamp to black/white
+inline irr::video::SColor multiplyColorValue(const irr::video::SColor &color, float mod)
+{
+       return irr::video::SColor(color.getAlpha(),
+                       core::clamp<u32>(color.getRed() * mod, 0, 255),
+                       core::clamp<u32>(color.getGreen() * mod, 0, 255),
+                       core::clamp<u32>(color.getBlue() * mod, 0, 255));
+}
+
+template <typename T> inline T numericAbsolute(T v) { return v < 0 ? T(-v) : v;                }
+template <typename T> inline T numericSign(T v)     { return T(v < 0 ? -1 : (v == 0 ? 0 : 1)); }
+
+inline v3f vecAbsolute(v3f v)
+{
+       return v3f(
+               numericAbsolute(v.X),
+               numericAbsolute(v.Y),
+               numericAbsolute(v.Z)
+       );
+}
+
+inline v3f vecSign(v3f v)
+{
+       return v3f(
+               numericSign(v.X),
+               numericSign(v.Y),
+               numericSign(v.Z)
+       );
+}