src/util/numeric.h

   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 #ifndef UTIL_NUMERIC_HEADER
  21 #define UTIL_NUMERIC_HEADER
  22
  23 #include "../irrlichttypes.h"
  24 #include "../irr_v2d.h"
  25 #include "../irr_v3d.h"
  26 #include "../irr_aabb3d.h"
  27 #include <list>
  28
  29 // Calculate the borders of a "d-radius" cube
  30 void getFacePositions(std::list<v3s16> &list, u16 d);
  31
  32 class IndentationRaiser
  33 {
  34 public:
  35         IndentationRaiser(u16 *indentation)
  36         {
  37                 m_indentation = indentation;
  38                 (*m_indentation)++;
  39         }
  40         ~IndentationRaiser()
  41         {
  42                 (*m_indentation)--;
  43         }
  44 private:
  45         u16 *m_indentation;
  46 };
  47
  48 inline s16 getContainerPos(s16 p, s16 d)
  49 {
  50         return (p>=0 ? p : p-d+1) / d;
  51 }
  52
  53 inline v2s16 getContainerPos(v2s16 p, s16 d)
  54 {
  55         return v2s16(
  56                 getContainerPos(p.X, d),
  57                 getContainerPos(p.Y, d)
  58         );
  59 }
  60
  61 inline v3s16 getContainerPos(v3s16 p, s16 d)
  62 {
  63         return v3s16(
  64                 getContainerPos(p.X, d),
  65                 getContainerPos(p.Y, d),
  66                 getContainerPos(p.Z, d)
  67         );
  68 }
  69
  70 inline v2s16 getContainerPos(v2s16 p, v2s16 d)
  71 {
  72         return v2s16(
  73                 getContainerPos(p.X, d.X),
  74                 getContainerPos(p.Y, d.Y)
  75         );
  76 }
  77
  78 inline v3s16 getContainerPos(v3s16 p, v3s16 d)
  79 {
  80         return v3s16(
  81                 getContainerPos(p.X, d.X),
  82                 getContainerPos(p.Y, d.Y),
  83                 getContainerPos(p.Z, d.Z)
  84         );
  85 }
  86
  87 inline bool isInArea(v3s16 p, s16 d)
  88 {
  89         return (
  90                 p.X >= 0 && p.X < d &&
  91                 p.Y >= 0 && p.Y < d &&
  92                 p.Z >= 0 && p.Z < d
  93         );
  94 }
  95
  96 inline bool isInArea(v2s16 p, s16 d)
  97 {
  98         return (
  99                 p.X >= 0 && p.X < d &&
 100                 p.Y >= 0 && p.Y < d
 101         );
 102 }
 103
 104 inline bool isInArea(v3s16 p, v3s16 d)
 105 {
 106         return (
 107                 p.X >= 0 && p.X < d.X &&
 108                 p.Y >= 0 && p.Y < d.Y &&
 109                 p.Z >= 0 && p.Z < d.Z
 110         );
 111 }
 112
 113 inline s16 rangelim(s16 i, s16 max)
 114 {
 115         if(i < 0)
 116                 return 0;
 117         if(i > max)
 118                 return max;
 119         return i;
 120 }
 121
 122 #define rangelim(d, min, max) ((d) < (min) ? (min) : ((d)>(max)?(max):(d)))
 123 #define myfloor(x) ((x) > 0.0 ? (int)(x) : (int)(x) - 1)
 124
 125 inline v3s16 arealim(v3s16 p, s16 d)
 126 {
 127         if(p.X < 0)
 128                 p.X = 0;
 129         if(p.Y < 0)
 130                 p.Y = 0;
 131         if(p.Z < 0)
 132                 p.Z = 0;
 133         if(p.X > d-1)
 134                 p.X = d-1;
 135         if(p.Y > d-1)
 136                 p.Y = d-1;
 137         if(p.Z > d-1)
 138                 p.Z = d-1;
 139         return p;
 140 }
 141
 142 // The naive swap performs better than the xor version
 143 #define SWAP(t, x, y) do { \
 144         t temp = x;            \
 145         x = y;                 \
 146         y = temp;              \
 147 } while (0)
 148
 149 inline void sortBoxVerticies(v3s16 &p1, v3s16 &p2) {
 150         if (p1.X > p2.X)
 151                 SWAP(s16, p1.X, p2.X);
 152         if (p1.Y > p2.Y)
 153                 SWAP(s16, p1.Y, p2.Y);
 154         if (p1.Z > p2.Z)
 155                 SWAP(s16, p1.Z, p2.Z);
 156 }
 157
 158
 159 /*
 160         See test.cpp for example cases.
 161         wraps degrees to the range of -360...360
 162         NOTE: Wrapping to 0...360 is not used because pitch needs negative values.
 163 */
 164 inline float wrapDegrees(float f)
 165 {
 166         // Take examples of f=10, f=720.5, f=-0.5, f=-360.5
 167         // This results in
 168         // 10, 720, -1, -361
 169         int i = floor(f);
 170         // 0, 2, 0, -1
 171         int l = i / 360;
 172         // NOTE: This would be used for wrapping to 0...360
 173         // 0, 2, -1, -2
 174         /*if(i < 0)
 175                 l -= 1;*/
 176         // 0, 720, 0, -360
 177         int k = l * 360;
 178         // 10, 0.5, -0.5, -0.5
 179         f -= float(k);
 180         return f;
 181 }
 182
 183 /* Wrap to 0...360 */
 184 inline float wrapDegrees_0_360(float f)
 185 {
 186         // Take examples of f=10, f=720.5, f=-0.5, f=-360.5
 187         // This results in
 188         // 10, 720, -1, -361
 189         int i = floor(f);
 190         // 0, 2, 0, -1
 191         int l = i / 360;
 192         // Wrap to 0...360
 193         // 0, 2, -1, -2
 194         if(i < 0)
 195                 l -= 1;
 196         // 0, 720, 0, -360
 197         int k = l * 360;
 198         // 10, 0.5, -0.5, -0.5
 199         f -= float(k);
 200         return f;
 201 }
 202
 203 /* Wrap to -180...180 */
 204 inline float wrapDegrees_180(float f)
 205 {
 206         f += 180;
 207         f = wrapDegrees_0_360(f);
 208         f -= 180;
 209         return f;
 210 }
 211
 212 /*
 213         Pseudo-random (VC++ rand() sucks)
 214 */
 215 int myrand(void);
 216 void mysrand(unsigned seed);
 217 #define MYRAND_MAX 32767
 218
 219 int myrand_range(int min, int max);
 220
 221 /*
 222         Miscellaneous functions
 223 */
 224
 225 u64 murmur_hash_64_ua(const void *key, int len, unsigned int seed);
 226
 227 bool isBlockInSight(v3s16 blockpos_b, v3f camera_pos, v3f camera_dir,
 228                 f32 camera_fov, f32 range, f32 *distance_ptr=NULL);
 229
 230 /*
 231         Some helper stuff
 232 */
 233 #define MYMIN(a,b) ((a)<(b)?(a):(b))
 234 #define MYMAX(a,b) ((a)>(b)?(a):(b))
 235
 236 /*
 237         Returns nearest 32-bit integer for given floating point number.
 238         <cmath> and <math.h> in VC++ don't provide round().
 239 */
 240 inline s32 myround(f32 f)
 241 {
 242         return floor(f + 0.5);
 243 }
 244
 245 /*
 246         Returns integer position of node in given floating point position
 247 */
 248 inline v3s16 floatToInt(v3f p, f32 d)
 249 {
 250         v3s16 p2(
 251                 (p.X + (p.X>0 ? d/2 : -d/2))/d,
 252                 (p.Y + (p.Y>0 ? d/2 : -d/2))/d,
 253                 (p.Z + (p.Z>0 ? d/2 : -d/2))/d);
 254         return p2;
 255 }
 256
 257 /*
 258         Returns floating point position of node in given integer position
 259 */
 260 inline v3f intToFloat(v3s16 p, f32 d)
 261 {
 262         v3f p2(
 263                 (f32)p.X * d,
 264                 (f32)p.Y * d,
 265                 (f32)p.Z * d
 266         );
 267         return p2;
 268 }
 269
 270 // Random helper. Usually d=BS
 271 inline core::aabbox3d<f32> getNodeBox(v3s16 p, float d)
 272 {
 273         return core::aabbox3d<f32>(
 274                 (float)p.X * d - 0.5*d,
 275                 (float)p.Y * d - 0.5*d,
 276                 (float)p.Z * d - 0.5*d,
 277                 (float)p.X * d + 0.5*d,
 278                 (float)p.Y * d + 0.5*d,
 279                 (float)p.Z * d + 0.5*d
 280         );
 281 }
 282
 283 class IntervalLimiter
 284 {
 285 public:
 286         IntervalLimiter():
 287                 m_accumulator(0)
 288         {
 289         }
 290         /*
 291                 dtime: time from last call to this method
 292                 wanted_interval: interval wanted
 293                 return value:
 294                         true: action should be skipped
 295                         false: action should be done
 296         */
 297         bool step(float dtime, float wanted_interval)
 298         {
 299                 m_accumulator += dtime;
 300                 if(m_accumulator < wanted_interval)
 301                         return false;
 302                 m_accumulator -= wanted_interval;
 303                 return true;
 304         }
 305 protected:
 306         float m_accumulator;
 307 };
 308
 309 /*
 310         Splits a list into "pages". For example, the list [1,2,3,4,5] split
 311         into two pages would be [1,2,3],[4,5]. This function computes the
 312         minimum and maximum indices of a single page.
 313
 314         length: Length of the list that should be split
 315         page: Page number, 1 <= page <= pagecount
 316         pagecount: The number of pages, >= 1
 317         minindex: Receives the minimum index (inclusive).
 318         maxindex: Receives the maximum index (exclusive).
 319
 320         Ensures 0 <= minindex <= maxindex <= length.
 321 */
 322 inline void paging(u32 length, u32 page, u32 pagecount, u32 &minindex, u32 &maxindex)
 323 {
 324         if(length < 1 || pagecount < 1 || page < 1 || page > pagecount)
 325         {
 326                 // Special cases or invalid parameters
 327                 minindex = maxindex = 0;
 328         }
 329         else if(pagecount <= length)
 330         {
 331                 // Less pages than entries in the list:
 332                 // Each page contains at least one entry
 333                 minindex = (length * (page-1) + (pagecount-1)) / pagecount;
 334                 maxindex = (length * page + (pagecount-1)) / pagecount;
 335         }
 336         else
 337         {
 338                 // More pages than entries in the list:
 339                 // Make sure the empty pages are at the end
 340                 if(page < length)
 341                 {
 342                         minindex = page-1;
 343                         maxindex = page;
 344                 }
 345                 else
 346                 {
 347                         minindex = 0;
 348                         maxindex = 0;
 349                 }
 350         }
 351 }
 352
 353 inline float cycle_shift(float value, float by = 0, float max = 1)
 354 {
 355     if (value + by < 0) return max + by + value;
 356     if (value + by > max) return value + by - max;
 357     return value + by;
 358 }
 359
 360 #endif
 361