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