src/noise.h

   1 /*
   2 Minetest
   3 Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4 Copyright (C) 2010-2013 kwolekr, Ryan Kwolek <kwolekr@minetest.net>
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU Lesser General Public License as published by
   8 the Free Software Foundation; either version 2.1 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU Lesser General Public License for more details.
  15
  16 You should have received a copy of the GNU Lesser General Public License along
  17 with this program; if not, write to the Free Software Foundation, Inc.,
  18 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 */
  20
  21 #ifndef NOISE_HEADER
  22 #define NOISE_HEADER
  23
  24 #include "debug.h"
  25 #include "irr_v3d.h"
  26
  27 class PseudoRandom
  28 {
  29 public:
  30         PseudoRandom(): m_next(0)
  31         {
  32         }
  33         PseudoRandom(int seed): m_next(seed)
  34         {
  35         }
  36         void seed(int seed)
  37         {
  38                 m_next = seed;
  39         }
  40         // Returns 0...32767
  41         int next()
  42         {
  43                 m_next = m_next * 1103515245 + 12345;
  44                 return((unsigned)(m_next/65536) % 32768);
  45         }
  46         int range(int min, int max)
  47         {
  48                 if(max-min > 32768/10)
  49                 {
  50                         //dstream<<"WARNING: PseudoRandom::range: max > 32767"<<std::endl;
  51                         assert(0);
  52                 }
  53                 if(min > max)
  54                 {
  55                         assert(0);
  56                         return max;
  57                 }
  58                 return (next()%(max-min+1))+min;
  59         }
  60 private:
  61         int m_next;
  62 };
  63
  64 struct NoiseParams {
  65         float offset;
  66         float scale;
  67         v3f spread;
  68         int seed;
  69         int octaves;
  70         float persist;
  71 };
  72
  73
  74 // Convenience macros for getting/setting NoiseParams in Settings
  75 #define getNoiseParams(x) getStruct<NoiseParams>((x), "f,f,v3,s32,s32,f")
  76 #define setNoiseParams(x, y) setStruct((x), "f,f,v3,s32,s32,f", (y))
  77
  78 class Noise {
  79 public:
  80         NoiseParams *np;
  81         int seed;
  82         int sx;
  83         int sy;
  84         int sz;
  85         float *noisebuf;
  86         float *buf;
  87         float *result;
  88
  89         Noise(NoiseParams *np, int seed, int sx, int sy);
  90         Noise(NoiseParams *np, int seed, int sx, int sy, int sz);
  91         ~Noise();
  92
  93         virtual void init(NoiseParams *np, int seed, int sx, int sy, int sz);
  94         void setSize(int sx, int sy);
  95         void setSize(int sx, int sy, int sz);
  96         void setSpreadFactor(v3f spread);
  97         void setOctaves(int octaves);
  98         void resizeNoiseBuf(bool is3d);
  99
 100         void gradientMap2D(
 101                 float x, float y,
 102                 float step_x, float step_y,
 103                 int seed);
 104         void gradientMap3D(
 105                 float x, float y, float z,
 106                 float step_x, float step_y, float step_z,
 107                 int seed);
 108         float *perlinMap2D(float x, float y);
 109         float *perlinMap2DModulated(float x, float y, float *persist_map);
 110         float *perlinMap3D(float x, float y, float z);
 111         void transformNoiseMap();
 112 };
 113
 114 // Return value: -1 ... 1
 115 float noise2d(int x, int y, int seed);
 116 float noise3d(int x, int y, int z, int seed);
 117
 118 float noise2d_gradient(float x, float y, int seed);
 119 float noise3d_gradient(float x, float y, float z, int seed);
 120
 121 float noise2d_perlin(float x, float y, int seed,
 122                 int octaves, float persistence);
 123
 124 float noise2d_perlin_abs(float x, float y, int seed,
 125                 int octaves, float persistence);
 126
 127 float noise3d_perlin(float x, float y, float z, int seed,
 128                 int octaves, float persistence);
 129
 130 float noise3d_perlin_abs(float x, float y, float z, int seed,
 131                 int octaves, float persistence);
 132
 133 inline float easeCurve(float t) {
 134         return t * t * t * (t * (6.f * t - 15.f) + 10.f);
 135 }
 136
 137 #define NoisePerlin2D(np, x, y, s) \
 138                 ((np)->offset + (np)->scale * noise2d_perlin( \
 139                 (float)(x) / (np)->spread.X, \
 140                 (float)(y) / (np)->spread.Y, \
 141                 (s) + (np)->seed, (np)->octaves, (np)->persist))
 142
 143 #define NoisePerlin2DNoTxfm(np, x, y, s) \
 144                 (noise2d_perlin( \
 145                 (float)(x) / (np)->spread.X, \
 146                 (float)(y) / (np)->spread.Y, \
 147                 (s) + (np)->seed, (np)->octaves, (np)->persist))
 148
 149 #define NoisePerlin2DPosOffset(np, x, xoff, y, yoff, s) \
 150                 ((np)->offset + (np)->scale * noise2d_perlin( \
 151                 (float)(xoff) + (float)(x) / (np)->spread.X, \
 152                 (float)(yoff) + (float)(y) / (np)->spread.Y, \
 153                 (s) + (np)->seed, (np)->octaves, (np)->persist))
 154
 155 #define NoisePerlin2DNoTxfmPosOffset(np, x, xoff, y, yoff, s) \
 156                 (noise2d_perlin( \
 157                 (float)(xoff) + (float)(x) / (np)->spread.X, \
 158                 (float)(yoff) + (float)(y) / (np)->spread.Y, \
 159                 (s) + (np)->seed, (np)->octaves, (np)->persist))
 160
 161 #define NoisePerlin3D(np, x, y, z, s) ((np)->offset + (np)->scale * \
 162                 noise3d_perlin((float)(x) / (np)->spread.X, (float)(y) / (np)->spread.Y, \
 163                 (float)(z) / (np)->spread.Z, (s) + (np)->seed, (np)->octaves, (np)->persist))
 164
 165 #endif
 166