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 #include "mathconstants.h"
  22
  23 #include "log.h"
  24 #include "../constants.h" // BS, MAP_BLOCKSIZE
  25 #include "../noise.h" // PseudoRandom, PcgRandom
  26 #include <string.h>
  27 #include <iostream>
  28
  29 std::map<u16, std::vector<v3s16> > FacePositionCache::m_cache;
  30 // Calculate the borders of a "d-radius" cube
  31 std::vector<v3s16> FacePositionCache::getFacePositions(u16 d)
  32 {
  33         if (m_cache.find(d) != m_cache.end())
  34                 return m_cache[d];
  35
  36         generateFacePosition(d);
  37         return m_cache[d];
  38
  39 }
  40
  41 void FacePositionCache::generateFacePosition(u16 d)
  42 {
  43         m_cache[d] = std::vector<v3s16>();
  44         if(d == 0) {
  45                 m_cache[d].push_back(v3s16(0,0,0));
  46                 return;
  47         }
  48         if(d == 1) {
  49                 /*
  50                         This is an optimized sequence of coordinates.
  51                 */
  52                 m_cache[d].push_back(v3s16( 0, 1, 0)); // top
  53                 m_cache[d].push_back(v3s16( 0, 0, 1)); // back
  54                 m_cache[d].push_back(v3s16(-1, 0, 0)); // left
  55                 m_cache[d].push_back(v3s16( 1, 0, 0)); // right
  56                 m_cache[d].push_back(v3s16( 0, 0,-1)); // front
  57                 m_cache[d].push_back(v3s16( 0,-1, 0)); // bottom
  58                 // 6
  59                 m_cache[d].push_back(v3s16(-1, 0, 1)); // back left
  60                 m_cache[d].push_back(v3s16( 1, 0, 1)); // back right
  61                 m_cache[d].push_back(v3s16(-1, 0,-1)); // front left
  62                 m_cache[d].push_back(v3s16( 1, 0,-1)); // front right
  63                 m_cache[d].push_back(v3s16(-1,-1, 0)); // bottom left
  64                 m_cache[d].push_back(v3s16( 1,-1, 0)); // bottom right
  65                 m_cache[d].push_back(v3s16( 0,-1, 1)); // bottom back
  66                 m_cache[d].push_back(v3s16( 0,-1,-1)); // bottom front
  67                 m_cache[d].push_back(v3s16(-1, 1, 0)); // top left
  68                 m_cache[d].push_back(v3s16( 1, 1, 0)); // top right
  69                 m_cache[d].push_back(v3s16( 0, 1, 1)); // top back
  70                 m_cache[d].push_back(v3s16( 0, 1,-1)); // top front
  71                 // 18
  72                 m_cache[d].push_back(v3s16(-1, 1, 1)); // top back-left
  73                 m_cache[d].push_back(v3s16( 1, 1, 1)); // top back-right
  74                 m_cache[d].push_back(v3s16(-1, 1,-1)); // top front-left
  75                 m_cache[d].push_back(v3s16( 1, 1,-1)); // top front-right
  76                 m_cache[d].push_back(v3s16(-1,-1, 1)); // bottom back-left
  77                 m_cache[d].push_back(v3s16( 1,-1, 1)); // bottom back-right
  78                 m_cache[d].push_back(v3s16(-1,-1,-1)); // bottom front-left
  79                 m_cache[d].push_back(v3s16( 1,-1,-1)); // bottom front-right
  80                 // 26
  81                 return;
  82         }
  83
  84         // Take blocks in all sides, starting from y=0 and going +-y
  85         for(s16 y=0; y<=d-1; y++) {
  86                 // Left and right side, including borders
  87                 for(s16 z=-d; z<=d; z++) {
  88                         m_cache[d].push_back(v3s16(d,y,z));
  89                         m_cache[d].push_back(v3s16(-d,y,z));
  90                         if(y != 0) {
  91                                 m_cache[d].push_back(v3s16(d,-y,z));
  92                                 m_cache[d].push_back(v3s16(-d,-y,z));
  93                         }
  94                 }
  95                 // Back and front side, excluding borders
  96                 for(s16 x=-d+1; x<=d-1; x++) {
  97                         m_cache[d].push_back(v3s16(x,y,d));
  98                         m_cache[d].push_back(v3s16(x,y,-d));
  99                         if(y != 0) {
 100                                 m_cache[d].push_back(v3s16(x,-y,d));
 101                                 m_cache[d].push_back(v3s16(x,-y,-d));
 102                         }
 103                 }
 104         }
 105
 106         // Take the bottom and top face with borders
 107         // -d<x<d, y=+-d, -d<z<d
 108         for(s16 x=-d; x<=d; x++)
 109         for(s16 z=-d; z<=d; z++) {
 110                 m_cache[d].push_back(v3s16(x,-d,z));
 111                 m_cache[d].push_back(v3s16(x,d,z));
 112         }
 113 }
 114
 115 /*
 116     myrand
 117 */
 118
 119 PcgRandom g_pcgrand;
 120
 121 u32 myrand()
 122 {
 123         return g_pcgrand.next();
 124 }
 125
 126 void mysrand(unsigned int seed)
 127 {
 128         g_pcgrand.seed(seed);
 129 }
 130
 131 void myrand_bytes(void *out, size_t len)
 132 {
 133         g_pcgrand.bytes(out, len);
 134 }
 135
 136 int myrand_range(int min, int max)
 137 {
 138         return g_pcgrand.range(min, max);
 139 }
 140
 141
 142 /*
 143         64-bit unaligned version of MurmurHash
 144 */
 145 u64 murmur_hash_64_ua(const void *key, int len, unsigned int seed)
 146 {
 147         const u64 m = 0xc6a4a7935bd1e995ULL;
 148         const int r = 47;
 149         u64 h = seed ^ (len * m);
 150
 151         const u64 *data = (const u64 *)key;
 152         const u64 *end = data + (len / 8);
 153
 154         while (data != end) {
 155                 u64 k;
 156                 memcpy(&k, data, sizeof(u64));
 157                 data++;
 158
 159                 k *= m;
 160                 k ^= k >> r;
 161                 k *= m;
 162
 163                 h ^= k;
 164                 h *= m;
 165         }
 166
 167         const unsigned char *data2 = (const unsigned char *)data;
 168         switch (len & 7) {
 169                 case 7: h ^= (u64)data2[6] << 48;
 170                 case 6: h ^= (u64)data2[5] << 40;
 171                 case 5: h ^= (u64)data2[4] << 32;
 172                 case 4: h ^= (u64)data2[3] << 24;
 173                 case 3: h ^= (u64)data2[2] << 16;
 174                 case 2: h ^= (u64)data2[1] << 8;
 175                 case 1: h ^= (u64)data2[0];
 176                                 h *= m;
 177         }
 178
 179         h ^= h >> r;
 180         h *= m;
 181         h ^= h >> r;
 182
 183         return h;
 184 }
 185
 186
 187 /*
 188         blockpos: position of block in block coordinates
 189         camera_pos: position of camera in nodes
 190         camera_dir: an unit vector pointing to camera direction
 191         range: viewing range
 192 */
 193 bool isBlockInSight(v3s16 blockpos_b, v3f camera_pos, v3f camera_dir,
 194                 f32 camera_fov, f32 range, f32 *distance_ptr)
 195 {
 196         v3s16 blockpos_nodes = blockpos_b * MAP_BLOCKSIZE;
 197
 198         // Block center position
 199         v3f blockpos(
 200                         ((float)blockpos_nodes.X + MAP_BLOCKSIZE/2) * BS,
 201                         ((float)blockpos_nodes.Y + MAP_BLOCKSIZE/2) * BS,
 202                         ((float)blockpos_nodes.Z + MAP_BLOCKSIZE/2) * BS
 203         );
 204
 205         // Block position relative to camera
 206         v3f blockpos_relative = blockpos - camera_pos;
 207
 208         // Total distance
 209         f32 d = blockpos_relative.getLength();
 210
 211         if(distance_ptr)
 212                 *distance_ptr = d;
 213
 214         // If block is far away, it's not in sight
 215         if(d > range)
 216                 return false;
 217
 218         // Maximum radius of a block.  The magic number is
 219         // sqrt(3.0) / 2.0 in literal form.
 220         f32 block_max_radius = 0.866025403784 * MAP_BLOCKSIZE * BS;
 221
 222         // If block is (nearly) touching the camera, don't
 223         // bother validating further (that is, render it anyway)
 224         if(d < block_max_radius)
 225                 return true;
 226
 227         // Adjust camera position, for purposes of computing the angle,
 228         // such that a block that has any portion visible with the
 229         // current camera position will have the center visible at the
 230         // adjusted postion
 231         f32 adjdist = block_max_radius / cos((M_PI - camera_fov) / 2);
 232
 233         // Block position relative to adjusted camera
 234         v3f blockpos_adj = blockpos - (camera_pos - camera_dir * adjdist);
 235
 236         // Distance in camera direction (+=front, -=back)
 237         f32 dforward = blockpos_adj.dotProduct(camera_dir);
 238
 239         // Cosine of the angle between the camera direction
 240         // and the block direction (camera_dir is an unit vector)
 241         f32 cosangle = dforward / blockpos_adj.getLength();
 242
 243         // If block is not in the field of view, skip it
 244         if(cosangle < cos(camera_fov / 2))
 245                 return false;
 246
 247         return true;
 248 }
 249