Fix typos and en_US/en_GB inconsistency in various files (#12902)

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

diff --git a/src/util/numeric.cpp b/src/util/numeric.cpp
index 12c91be913ff05ce3a2529781703998d0e40cf30..3bcac5335c5fd633e94a01557ba0cfa6ccff9757 100644 (file)
--- a/src/util/numeric.cpp
+++ b/src/util/numeric.cpp
@@ -46,11 +46,22 @@ void myrand_bytes(void *out, size_t len)
        g_pcgrand.bytes(out, len);
 }
 
+float myrand_float()
+{
+       u32 uv = g_pcgrand.next();
+       return (float)uv / (float)U32_MAX;
+}
+
 int myrand_range(int min, int max)
 {
        return g_pcgrand.range(min, max);
 }
 
+float myrand_range(float min, float max)
+{
+       return (max-min) * myrand_float() + min;
+}
+
 
 /*
        64-bit unaligned version of MurmurHash
@@ -61,13 +72,13 @@ u64 murmur_hash_64_ua(const void *key, int len, unsigned int seed)
        const int r = 47;
        u64 h = seed ^ (len * m);
 
-       const u64 *data = (const u64 *)key;
-       const u64 *end = data + (len / 8);
+       const u8 *data = (const u8 *)key;
+       const u8 *end = data + (len / 8) * 8;
 
        while (data != end) {
                u64 k;
                memcpy(&k, data, sizeof(u64));
-               data++;
+               data += sizeof(u64);
 
                k *= m;
                k ^= k >> r;
@@ -106,10 +117,6 @@ 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)
 {
-       // Maximum radius of a block.  The magic number is
-       // sqrt(3.0) / 2.0 in literal form.
-       const f32 block_max_radius = 0.866025403784 * MAP_BLOCKSIZE * BS;
-
        v3s16 blockpos_nodes = blockpos_b * MAP_BLOCKSIZE;
 
        // Block center position
@@ -123,25 +130,25 @@ bool isBlockInSight(v3s16 blockpos_b, v3f camera_pos, v3f camera_dir,
        v3f blockpos_relative = blockpos - camera_pos;
 
        // Total distance
-       f32 d = MYMAX(0, blockpos_relative.getLength() - block_max_radius);
+       f32 d = MYMAX(0, blockpos_relative.getLength() - BLOCK_MAX_RADIUS);
 
-       if(distance_ptr)
+       if (distance_ptr)
                *distance_ptr = d;
 
        // If block is far away, it's not in sight
-       if(d > range)
+       if (d > range)
                return false;
 
        // If block is (nearly) touching the camera, don't
        // bother validating further (that is, render it anyway)
-       if(d == 0)
+       if (d == 0)
                return true;
 
        // Adjust camera position, for purposes of computing the angle,
        // such that a block that has any portion visible with the
        // current camera position will have the center visible at the
-       // adjusted postion
-       f32 adjdist = block_max_radius / cos((M_PI - camera_fov) / 2);
+       // adjusted position
+       f32 adjdist = BLOCK_MAX_RADIUS / cos((M_PI - camera_fov) / 2);
 
        // Block position relative to adjusted camera
        v3f blockpos_adj = blockpos - (camera_pos - camera_dir * adjdist);
@@ -154,24 +161,63 @@ bool isBlockInSight(v3s16 blockpos_b, v3f camera_pos, v3f camera_dir,
        f32 cosangle = dforward / blockpos_adj.getLength();
 
        // If block is not in the field of view, skip it
-       // HOTFIX: use sligthly increased angle (+10%) to fix too agressive
+       // HOTFIX: use sligthly increased angle (+10%) to fix too aggressive
        // culling. Somebody have to find out whats wrong with the math here.
        // Previous value: camera_fov / 2
-       if(cosangle < cos(camera_fov * 0.55))
+       if (cosangle < std::cos(camera_fov * 0.55f))
                return false;
 
        return true;
 }
 
-s16 adjustDist(s16 dist, float zoom_fov)
+inline float adjustDist(float dist, float zoom_fov)
 {
-       // 1.775 ~= 72 * PI / 180 * 1.4, the default on the client
-       const float default_fov = 1.775f;
-       // heuristic cut-off for zooming
-       if (zoom_fov > default_fov / 2.0f)
+       // 1.775 ~= 72 * PI / 180 * 1.4, the default FOV on the client.
+       // The heuristic threshold for zooming is half of that.
+       static constexpr const float threshold_fov = 1.775f / 2.0f;
+       if (zoom_fov < 0.001f || zoom_fov > threshold_fov)
                return dist;
 
-       // new_dist = dist * ((1 - cos(FOV / 2)) / (1-cos(zoomFOV /2))) ^ (1/3)
-       return round(dist * cbrt((1.0f - cos(default_fov / 2.0f)) /
-               (1.0f - cos(zoom_fov / 2.0f))));
+       return dist * std::cbrt((1.0f - std::cos(threshold_fov)) /
+               (1.0f - std::cos(zoom_fov / 2.0f)));
+}
+
+s16 adjustDist(s16 dist, float zoom_fov)
+{
+       return std::round(adjustDist((float)dist, zoom_fov));
+}
+
+void setPitchYawRollRad(core::matrix4 &m, const v3f &rot)
+{
+       f64 a1 = rot.Z, a2 = rot.X, a3 = rot.Y;
+       f64 c1 = cos(a1), s1 = sin(a1);
+       f64 c2 = cos(a2), s2 = sin(a2);
+       f64 c3 = cos(a3), s3 = sin(a3);
+       f32 *M = m.pointer();
+
+       M[0] = s1 * s2 * s3 + c1 * c3;
+       M[1] = s1 * c2;
+       M[2] = s1 * s2 * c3 - c1 * s3;
+
+       M[4] = c1 * s2 * s3 - s1 * c3;
+       M[5] = c1 * c2;
+       M[6] = c1 * s2 * c3 + s1 * s3;
+
+       M[8] = c2 * s3;
+       M[9] = -s2;
+       M[10] = c2 * c3;
+}
+
+v3f getPitchYawRollRad(const core::matrix4 &m)
+{
+       const f32 *M = m.pointer();
+
+       f64 a1 = atan2(M[1], M[5]);
+       f32 c2 = std::sqrt((f64)M[10]*M[10] + (f64)M[8]*M[8]);
+       f32 a2 = atan2f(-M[9], c2);
+       f64 c1 = cos(a1);
+       f64 s1 = sin(a1);
+       f32 a3 = atan2f(s1*M[6] - c1*M[2], c1*M[0] - s1*M[4]);
+
+       return v3f(a2, a3, a1);
 }