src/util/numeric.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   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.
   9
  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.
  14
  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.
  18 */
  19
  20 #include "numeric.h"
  21
  22 #include "log.h"
  23 #include "constants.h" // BS, MAP_BLOCKSIZE
  24 #include "noise.h" // PseudoRandom, PcgRandom
  25 #include "threading/mutex_auto_lock.h"
  26 #include <cstring>
  27 #include <cmath>
  28
  29
  30 // myrand
  31
  32 PcgRandom g_pcgrand;
  33
  34 u32 myrand()
  35 {
  36         return g_pcgrand.next();
  37 }
  38
  39 void mysrand(unsigned int seed)
  40 {
  41         g_pcgrand.seed(seed);
  42 }
  43
  44 void myrand_bytes(void *out, size_t len)
  45 {
  46         g_pcgrand.bytes(out, len);
  47 }
  48
  49 float myrand_float()
  50 {
  51         u32 uv = g_pcgrand.next();
  52         return (float)uv / (float)U32_MAX;
  53 }
  54
  55 int myrand_range(int min, int max)
  56 {
  57         return g_pcgrand.range(min, max);
  58 }
  59
  60 float myrand_range(float min, float max)
  61 {
  62         return (max-min) * myrand_float() + min;
  63 }
  64
  65
  66 /*
  67         64-bit unaligned version of MurmurHash
  68 */
  69 u64 murmur_hash_64_ua(const void *key, int len, unsigned int seed)
  70 {
  71         const u64 m = 0xc6a4a7935bd1e995ULL;
  72         const int r = 47;
  73         u64 h = seed ^ (len * m);
  74
  75         const u8 *data = (const u8 *)key;
  76         const u8 *end = data + (len / 8) * 8;
  77
  78         while (data != end) {
  79                 u64 k;
  80                 memcpy(&k, data, sizeof(u64));
  81                 data += sizeof(u64);
  82
  83                 k *= m;
  84                 k ^= k >> r;
  85                 k *= m;
  86
  87                 h ^= k;
  88                 h *= m;
  89         }
  90
  91         const unsigned char *data2 = (const unsigned char *)data;
  92         switch (len & 7) {
  93                 case 7: h ^= (u64)data2[6] << 48;
  94                 case 6: h ^= (u64)data2[5] << 40;
  95                 case 5: h ^= (u64)data2[4] << 32;
  96                 case 4: h ^= (u64)data2[3] << 24;
  97                 case 3: h ^= (u64)data2[2] << 16;
  98                 case 2: h ^= (u64)data2[1] << 8;
  99                 case 1: h ^= (u64)data2[0];
 100                                 h *= m;
 101         }
 102
 103         h ^= h >> r;
 104         h *= m;
 105         h ^= h >> r;
 106
 107         return h;
 108 }
 109
 110 /*
 111         blockpos_b: position of block in block coordinates
 112         camera_pos: position of camera in nodes
 113         camera_dir: an unit vector pointing to camera direction
 114         range: viewing range
 115         distance_ptr: return location for distance from the camera
 116 */
 117 bool isBlockInSight(v3s16 blockpos_b, v3f camera_pos, v3f camera_dir,
 118                 f32 camera_fov, f32 range, f32 *distance_ptr)
 119 {
 120         v3s16 blockpos_nodes = blockpos_b * MAP_BLOCKSIZE;
 121
 122         // Block center position
 123         v3f blockpos(
 124                         ((float)blockpos_nodes.X + MAP_BLOCKSIZE/2) * BS,
 125                         ((float)blockpos_nodes.Y + MAP_BLOCKSIZE/2) * BS,
 126                         ((float)blockpos_nodes.Z + MAP_BLOCKSIZE/2) * BS
 127         );
 128
 129         // Block position relative to camera
 130         v3f blockpos_relative = blockpos - camera_pos;
 131
 132         // Total distance
 133         f32 d = MYMAX(0, blockpos_relative.getLength() - BLOCK_MAX_RADIUS);
 134
 135         if (distance_ptr)
 136                 *distance_ptr = d;
 137
 138         // If block is far away, it's not in sight
 139         if (d > range)
 140                 return false;
 141
 142         // If block is (nearly) touching the camera, don't
 143         // bother validating further (that is, render it anyway)
 144         if (d == 0)
 145                 return true;
 146
 147         // Adjust camera position, for purposes of computing the angle,
 148         // such that a block that has any portion visible with the
 149         // current camera position will have the center visible at the
 150         // adjusted postion
 151         f32 adjdist = BLOCK_MAX_RADIUS / cos((M_PI - camera_fov) / 2);
 152
 153         // Block position relative to adjusted camera
 154         v3f blockpos_adj = blockpos - (camera_pos - camera_dir * adjdist);
 155
 156         // Distance in camera direction (+=front, -=back)
 157         f32 dforward = blockpos_adj.dotProduct(camera_dir);
 158
 159         // Cosine of the angle between the camera direction
 160         // and the block direction (camera_dir is an unit vector)
 161         f32 cosangle = dforward / blockpos_adj.getLength();
 162
 163         // If block is not in the field of view, skip it
 164         // HOTFIX: use sligthly increased angle (+10%) to fix too agressive
 165         // culling. Somebody have to find out whats wrong with the math here.
 166         // Previous value: camera_fov / 2
 167         if (cosangle < std::cos(camera_fov * 0.55f))
 168                 return false;
 169
 170         return true;
 171 }
 172
 173 inline float adjustDist(float dist, float zoom_fov)
 174 {
 175         // 1.775 ~= 72 * PI / 180 * 1.4, the default FOV on the client.
 176         // The heuristic threshold for zooming is half of that.
 177         static constexpr const float threshold_fov = 1.775f / 2.0f;
 178         if (zoom_fov < 0.001f || zoom_fov > threshold_fov)
 179                 return dist;
 180
 181         return dist * std::cbrt((1.0f - std::cos(threshold_fov)) /
 182                 (1.0f - std::cos(zoom_fov / 2.0f)));
 183 }
 184
 185 s16 adjustDist(s16 dist, float zoom_fov)
 186 {
 187         return std::round(adjustDist((float)dist, zoom_fov));
 188 }
 189
 190 void setPitchYawRollRad(core::matrix4 &m, const v3f &rot)
 191 {
 192         f64 a1 = rot.Z, a2 = rot.X, a3 = rot.Y;
 193         f64 c1 = cos(a1), s1 = sin(a1);
 194         f64 c2 = cos(a2), s2 = sin(a2);
 195         f64 c3 = cos(a3), s3 = sin(a3);
 196         f32 *M = m.pointer();
 197
 198         M[0] = s1 * s2 * s3 + c1 * c3;
 199         M[1] = s1 * c2;
 200         M[2] = s1 * s2 * c3 - c1 * s3;
 201
 202         M[4] = c1 * s2 * s3 - s1 * c3;
 203         M[5] = c1 * c2;
 204         M[6] = c1 * s2 * c3 + s1 * s3;
 205
 206         M[8] = c2 * s3;
 207         M[9] = -s2;
 208         M[10] = c2 * c3;
 209 }
 210
 211 v3f getPitchYawRollRad(const core::matrix4 &m)
 212 {
 213         const f32 *M = m.pointer();
 214
 215         f64 a1 = atan2(M[1], M[5]);
 216         f32 c2 = std::sqrt((f64)M[10]*M[10] + (f64)M[8]*M[8]);
 217         f32 a2 = atan2f(-M[9], c2);
 218         f64 c1 = cos(a1);
 219         f64 s1 = sin(a1);
 220         f32 a3 = atan2f(s1*M[6] - c1*M[2], c1*M[0] - s1*M[4]);
 221
 222         return v3f(a2, a3, a1);
 223 }