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 "debug.h"
  30 #include "irr_v3d.h"
  31 #include "util/string.h"
  32
  33 extern FlagDesc flagdesc_noiseparams[];
  34
  35 class PseudoRandom
  36 {
  37 public:
  38         PseudoRandom(): m_next(0)
  39         {
  40         }
  41         PseudoRandom(int seed): m_next(seed)
  42         {
  43         }
  44         void seed(int seed)
  45         {
  46                 m_next = seed;
  47         }
  48         // Returns 0...32767
  49         int next()
  50         {
  51                 m_next = m_next * 1103515245 + 12345;
  52                 return((unsigned)(m_next/65536) % 32768);
  53         }
  54         int range(int min, int max)
  55         {
  56                 if(max-min > 32768/10)
  57                 {
  58                         //dstream<<"WARNING: PseudoRandom::range: max > 32767"<<std::endl;
  59                         assert(0);
  60                 }
  61                 if(min > max)
  62                 {
  63                         assert(0);
  64                         return max;
  65                 }
  66                 return (next()%(max-min+1))+min;
  67         }
  68 private:
  69         int m_next;
  70 };
  71
  72 #define NOISE_FLAG_DEFAULTS    0x01
  73 #define NOISE_FLAG_EASED       0x02
  74 #define NOISE_FLAG_ABSVALUE    0x04
  75
  76 //// TODO(hmmmm): implement these!
  77 #define NOISE_FLAG_POINTBUFFER 0x08
  78 #define NOISE_FLAG_SIMPLEX     0x10
  79
  80 struct NoiseParams {
  81         float offset;
  82         float scale;
  83         v3f spread;
  84         s32 seed;
  85         u16 octaves;
  86         float persist;
  87         float lacunarity;
  88         u32 flags;
  89
  90         NoiseParams() {
  91                 offset     = 0.0f;
  92                 scale      = 1.0f;
  93                 spread     = v3f(250, 250, 250);
  94                 seed       = 12345;
  95                 octaves    = 3;
  96                 persist    = 0.6f;
  97                 lacunarity = 2.0f;
  98                 flags      = NOISE_FLAG_DEFAULTS;
  99         }
 100
 101         NoiseParams(float offset_, float scale_, v3f spread_, s32 seed_,
 102                 u16 octaves_, float persist_, float lacunarity_,
 103                 u32 flags_=NOISE_FLAG_DEFAULTS)
 104         {
 105                 offset     = offset_;
 106                 scale      = scale_;
 107                 spread     = spread_;
 108                 seed       = seed_;
 109                 octaves    = octaves_;
 110                 persist    = persist_;
 111                 lacunarity = lacunarity_;
 112                 flags      = flags_;
 113         }
 114 };
 115
 116
 117 // Convenience macros for getting/setting NoiseParams in Settings as a string
 118 // WARNING:  Deprecated, use Settings::getNoiseParamsFromValue() instead
 119 #define NOISEPARAMS_FMT_STR "f,f,v3,s32,u16,f"
 120 //#define getNoiseParams(x, y) getStruct((x), NOISEPARAMS_FMT_STR, &(y), sizeof(y))
 121 //#define setNoiseParams(x, y) setStruct((x), NOISEPARAMS_FMT_STR, &(y))
 122
 123 class Noise {
 124 public:
 125         NoiseParams np;
 126         int seed;
 127         int sx;
 128         int sy;
 129         int sz;
 130         float *noise_buf;
 131         float *gradient_buf;
 132         float *persist_buf;
 133         float *result;
 134
 135         Noise(NoiseParams *np, int seed, int sx, int sy, int sz=1);
 136         ~Noise();
 137
 138         void setSize(int sx, int sy, int sz=1);
 139         void setSpreadFactor(v3f spread);
 140         void setOctaves(int octaves);
 141
 142         void gradientMap2D(
 143                 float x, float y,
 144                 float step_x, float step_y,
 145                 int seed);
 146         void gradientMap3D(
 147                 float x, float y, float z,
 148                 float step_x, float step_y, float step_z,
 149                 int seed);
 150
 151         float *perlinMap2D(float x, float y, float *persistence_map=NULL);
 152         float *perlinMap3D(float x, float y, float z, float *persistence_map=NULL);
 153
 154 private:
 155         void allocBuffers();
 156         void resizeNoiseBuf(bool is3d);
 157         void updateResults(float g, float *gmap, float *persistence_map, size_t bufsize);
 158
 159 };
 160
 161 // Return value: -1 ... 1
 162 float noise2d(int x, int y, int seed);
 163 float noise3d(int x, int y, int z, int seed);
 164
 165 float noise2d_gradient(float x, float y, int seed, bool eased=true);
 166 float noise3d_gradient(float x, float y, float z, int seed, bool eased=false);
 167
 168 float noise2d_perlin(float x, float y, int seed,
 169                 int octaves, float persistence, bool eased=true);
 170
 171 float noise2d_perlin_abs(float x, float y, int seed,
 172                 int octaves, float persistence, bool eased=true);
 173
 174 float noise3d_perlin(float x, float y, float z, int seed,
 175                 int octaves, float persistence, bool eased=false);
 176
 177 float noise3d_perlin_abs(float x, float y, float z, int seed,
 178                 int octaves, float persistence, bool eased=false);
 179
 180 inline float easeCurve(float t)
 181 {
 182         return t * t * t * (t * (6.f * t - 15.f) + 10.f);
 183 }
 184
 185 float contour(float v);
 186
 187 #define NoisePerlin2D(np, x, y, s) \
 188                 ((np)->offset + (np)->scale * noise2d_perlin( \
 189                 (float)(x) / (np)->spread.X, \
 190                 (float)(y) / (np)->spread.Y, \
 191                 (s) + (np)->seed, (np)->octaves, (np)->persist))
 192
 193 #define NoisePerlin2DNoTxfm(np, x, y, s) \
 194                 (noise2d_perlin( \
 195                 (float)(x) / (np)->spread.X, \
 196                 (float)(y) / (np)->spread.Y, \
 197                 (s) + (np)->seed, (np)->octaves, (np)->persist))
 198
 199 #define NoisePerlin2DPosOffset(np, x, xoff, y, yoff, s) \
 200                 ((np)->offset + (np)->scale * noise2d_perlin( \
 201                 (float)(xoff) + (float)(x) / (np)->spread.X, \
 202                 (float)(yoff) + (float)(y) / (np)->spread.Y, \
 203                 (s) + (np)->seed, (np)->octaves, (np)->persist))
 204
 205 #define NoisePerlin2DNoTxfmPosOffset(np, x, xoff, y, yoff, s) \
 206                 (noise2d_perlin( \
 207                 (float)(xoff) + (float)(x) / (np)->spread.X, \
 208                 (float)(yoff) + (float)(y) / (np)->spread.Y, \
 209                 (s) + (np)->seed, (np)->octaves, (np)->persist))
 210
 211 #define NoisePerlin3D(np, x, y, z, s) ((np)->offset + (np)->scale * \
 212                 noise3d_perlin((float)(x) / (np)->spread.X, (float)(y) / (np)->spread.Y, \
 213                 (float)(z) / (np)->spread.Z, (s) + (np)->seed, (np)->octaves, (np)->persist))
 214
 215 #define NoisePerlin3DEased(np, x, y, z, s) ((np)->offset + (np)->scale * \
 216                 noise3d_perlin((float)(x) / (np)->spread.X, (float)(y) / (np)->spread.Y, \
 217                 (float)(z) / (np)->spread.Z, (s) + (np)->seed, (np)->octaves, \
 218                 (np)->persist, true))
 219
 220 #endif
 221