src/noise.h

   1 /*
   2  * Minetest
   3  * Copyright (C) 2010-2014 celeron55, Perttu Ahola <celeron55@gmail.com>
   4  * Copyright (C) 2010-2014 kwolekr, Ryan Kwolek <kwolekr@minetest.net>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without modification, are
   8  * permitted provided that the following conditions are met:
   9  *  1. Redistributions of source code must retain the above copyright notice, this list of
  10  *     conditions and the following disclaimer.
  11  *  2. Redistributions in binary form must reproduce the above copyright notice, this list
  12  *     of conditions and the following disclaimer in the documentation and/or other materials
  13  *     provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED
  16  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  17  * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR
  18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  19  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  20  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  21  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  22  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  23  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #ifndef NOISE_HEADER
  27 #define NOISE_HEADER
  28
  29 #include "irr_v3d.h"
  30 #include "exceptions.h"
  31 #include "util/string.h"
  32
  33 extern FlagDesc flagdesc_noiseparams[];
  34
  35 // Note: this class is not polymorphic so that its high level of
  36 // optimizability may be preserved in the common use case
  37 class PseudoRandom {
  38 public:
  39         const static u32 RANDOM_RANGE = 32767;
  40
  41         inline PseudoRandom(int seed=0):
  42                 m_next(seed)
  43         {
  44         }
  45
  46         inline void seed(int seed)
  47         {
  48                 m_next = seed;
  49         }
  50
  51         inline int next()
  52         {
  53                 m_next = m_next * 1103515245 + 12345;
  54                 return (unsigned)(m_next / 65536) % (RANDOM_RANGE + 1);
  55         }
  56
  57         inline int range(int min, int max)
  58         {
  59                 if (max < min)
  60                         throw PrngException("Invalid range (max < min)");
  61                 /*
  62                 Here, we ensure the range is not too large relative to RANDOM_MAX,
  63                 as otherwise the effects of bias would become noticable.  Unlike
  64                 PcgRandom, we cannot modify this RNG's range as it would change the
  65                 output of this RNG for reverse compatibility.
  66                 */
  67                 if ((u32)(max - min) > (RANDOM_RANGE + 1) / 10)
  68                         throw PrngException("Range too large");
  69
  70                 return (next() % (max - min + 1)) + min;
  71         }
  72
  73 private:
  74         int m_next;
  75 };
  76
  77 class PcgRandom {
  78 public:
  79         const static s32 RANDOM_MIN   = -0x7fffffff - 1;
  80         const static s32 RANDOM_MAX   = 0x7fffffff;
  81         const static u32 RANDOM_RANGE = 0xffffffff;
  82
  83         PcgRandom(u64 state=0x853c49e6748fea9bULL, u64 seq=0xda3e39cb94b95bdbULL);
  84         void seed(u64 state, u64 seq=0xda3e39cb94b95bdbULL);
  85         u32 next();
  86         u32 range(u32 bound);
  87         s32 range(s32 min, s32 max);
  88         void bytes(void *out, size_t len);
  89         s32 randNormalDist(s32 min, s32 max, int num_trials=6);
  90
  91 private:
  92         u64 m_state;
  93         u64 m_inc;
  94 };
  95
  96 #define NOISE_FLAG_DEFAULTS    0x01
  97 #define NOISE_FLAG_EASED       0x02
  98 #define NOISE_FLAG_ABSVALUE    0x04
  99
 100 //// TODO(hmmmm): implement these!
 101 #define NOISE_FLAG_POINTBUFFER 0x08
 102 #define NOISE_FLAG_SIMPLEX     0x10
 103
 104 struct NoiseParams {
 105         float offset = 0.0f;
 106         float scale = 1.0f;
 107         v3f spread = v3f(250, 250, 250);
 108         s32 seed = 12345;
 109         u16 octaves = 3;
 110         float persist = 0.6f;
 111         float lacunarity = 2.0f;
 112         u32 flags = NOISE_FLAG_DEFAULTS;
 113
 114         NoiseParams() {}
 115
 116         NoiseParams(float offset_, float scale_, v3f spread_, s32 seed_,
 117                 u16 octaves_, float persist_, float lacunarity_,
 118                 u32 flags_=NOISE_FLAG_DEFAULTS)
 119         {
 120                 offset     = offset_;
 121                 scale      = scale_;
 122                 spread     = spread_;
 123                 seed       = seed_;
 124                 octaves    = octaves_;
 125                 persist    = persist_;
 126                 lacunarity = lacunarity_;
 127                 flags      = flags_;
 128         }
 129 };
 130
 131 class Noise {
 132 public:
 133         NoiseParams np;
 134         s32 seed;
 135         u32 sx;
 136         u32 sy;
 137         u32 sz;
 138         float *noise_buf = nullptr;
 139         float *gradient_buf = nullptr;
 140         float *persist_buf = nullptr;
 141         float *result = nullptr;
 142
 143         Noise(NoiseParams *np, s32 seed, u32 sx, u32 sy, u32 sz=1);
 144         ~Noise();
 145
 146         void setSize(u32 sx, u32 sy, u32 sz=1);
 147         void setSpreadFactor(v3f spread);
 148         void setOctaves(int octaves);
 149
 150         void gradientMap2D(
 151                 float x, float y,
 152                 float step_x, float step_y,
 153                 s32 seed);
 154         void gradientMap3D(
 155                 float x, float y, float z,
 156                 float step_x, float step_y, float step_z,
 157                 s32 seed);
 158
 159         float *perlinMap2D(float x, float y, float *persistence_map=NULL);
 160         float *perlinMap3D(float x, float y, float z, float *persistence_map=NULL);
 161
 162         inline float *perlinMap2D_PO(float x, float xoff, float y, float yoff,
 163                 float *persistence_map=NULL)
 164         {
 165                 return perlinMap2D(
 166                         x + xoff * np.spread.X,
 167                         y + yoff * np.spread.Y,
 168                         persistence_map);
 169         }
 170
 171         inline float *perlinMap3D_PO(float x, float xoff, float y, float yoff,
 172                 float z, float zoff, float *persistence_map=NULL)
 173         {
 174                 return perlinMap3D(
 175                         x + xoff * np.spread.X,
 176                         y + yoff * np.spread.Y,
 177                         z + zoff * np.spread.Z,
 178                         persistence_map);
 179         }
 180
 181 private:
 182         void allocBuffers();
 183         void resizeNoiseBuf(bool is3d);
 184         void updateResults(float g, float *gmap, float *persistence_map, size_t bufsize);
 185
 186 };
 187
 188 float NoisePerlin2D(NoiseParams *np, float x, float y, s32 seed);
 189 float NoisePerlin3D(NoiseParams *np, float x, float y, float z, s32 seed);
 190
 191 inline float NoisePerlin2D_PO(NoiseParams *np, float x, float xoff,
 192         float y, float yoff, s32 seed)
 193 {
 194         return NoisePerlin2D(np,
 195                 x + xoff * np->spread.X,
 196                 y + yoff * np->spread.Y,
 197                 seed);
 198 }
 199
 200 inline float NoisePerlin3D_PO(NoiseParams *np, float x, float xoff,
 201         float y, float yoff, float z, float zoff, s32 seed)
 202 {
 203         return NoisePerlin3D(np,
 204                 x + xoff * np->spread.X,
 205                 y + yoff * np->spread.Y,
 206                 z + zoff * np->spread.Z,
 207                 seed);
 208 }
 209
 210 // Return value: -1 ... 1
 211 float noise2d(int x, int y, s32 seed);
 212 float noise3d(int x, int y, int z, s32 seed);
 213
 214 float noise2d_gradient(float x, float y, s32 seed, bool eased=true);
 215 float noise3d_gradient(float x, float y, float z, s32 seed, bool eased=false);
 216
 217 float noise2d_perlin(float x, float y, s32 seed,
 218                 int octaves, float persistence, bool eased=true);
 219
 220 float noise2d_perlin_abs(float x, float y, s32 seed,
 221                 int octaves, float persistence, bool eased=true);
 222
 223 float noise3d_perlin(float x, float y, float z, s32 seed,
 224                 int octaves, float persistence, bool eased=false);
 225
 226 float noise3d_perlin_abs(float x, float y, float z, s32 seed,
 227                 int octaves, float persistence, bool eased=false);
 228
 229 inline float easeCurve(float t)
 230 {
 231         return t * t * t * (t * (6.f * t - 15.f) + 10.f);
 232 }
 233
 234 float contour(float v);
 235
 236 #endif
 237