src/noise.h

   1 /*
   2 Minetest-c55
   3 Copyright (C) 2010-2011 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 NOISE_HEADER
  21 #define NOISE_HEADER
  22
  23 #include "debug.h"
  24 #include "irr_v3d.h"
  25
  26 class PseudoRandom
  27 {
  28 public:
  29         PseudoRandom(): m_next(0)
  30         {
  31         }
  32         PseudoRandom(int seed): m_next(seed)
  33         {
  34         }
  35         void seed(int seed)
  36         {
  37                 m_next = seed;
  38         }
  39         // Returns 0...32767
  40         int next()
  41         {
  42                 m_next = m_next * 1103515245 + 12345;
  43                 return((unsigned)(m_next/65536) % 32768);
  44         }
  45         int range(int min, int max)
  46         {
  47                 if(max-min > 32768/10)
  48                 {
  49                         //dstream<<"WARNING: PseudoRandom::range: max > 32767"<<std::endl;
  50                         assert(0);
  51                 }
  52                 if(min > max)
  53                 {
  54                         assert(0);
  55                         return max;
  56                 }
  57                 return (next()%(max-min+1))+min;
  58         }
  59 private:
  60         int m_next;
  61 };
  62
  63 struct NoiseParams {
  64         float offset;
  65         float scale;
  66         v3f spread;
  67         int seed;
  68         int octaves;
  69         float persist;
  70 };
  71
  72
  73 class Noise {
  74 public:
  75         NoiseParams *np;
  76         int seed;
  77         int sx;
  78         int sy;
  79         int sz;
  80         float *noisebuf;
  81         float *buf;
  82         float *result;
  83
  84         Noise(NoiseParams *np, int seed, int sx, int sy);
  85         Noise(NoiseParams *np, int seed, int sx, int sy, int sz);
  86         ~Noise();
  87
  88         void init(NoiseParams *np, int seed, int sx, int sy, int sz);
  89         void setSize(int sx, int sy);
  90         void setSize(int sx, int sy, int sz);
  91         void setSpreadFactor(v3f spread);
  92         void setOctaves(int octaves);
  93         void resizeNoiseBuf(bool is3d);
  94
  95         void gradientMap2D(
  96                 float x, float y,
  97                 float step_x, float step_y,
  98                 int seed);
  99         void gradientMap3D(
 100                 float x, float y, float z,
 101                 float step_x, float step_y, float step_z,
 102                 int seed);
 103         float *perlinMap2D(float x, float y);
 104         float *perlinMap3D(float x, float y, float z);
 105         void transformNoiseMap();
 106 };
 107
 108 // Return value: -1 ... 1
 109 float noise2d(int x, int y, int seed);
 110 float noise3d(int x, int y, int z, int seed);
 111
 112 float noise2d_gradient(float x, float y, int seed);
 113 float noise3d_gradient(float x, float y, float z, int seed);
 114
 115 float noise2d_perlin(float x, float y, int seed,
 116                 int octaves, float persistence);
 117
 118 float noise2d_perlin_abs(float x, float y, int seed,
 119                 int octaves, float persistence);
 120
 121 float noise3d_perlin(float x, float y, float z, int seed,
 122                 int octaves, float persistence);
 123
 124 float noise3d_perlin_abs(float x, float y, float z, int seed,
 125                 int octaves, float persistence);
 126
 127 inline float easeCurve(float t) {
 128         return t * t * t * (t * (6.f * t - 15.f) + 10.f);
 129 }
 130
 131 #define NoisePerlin2D(np, x, y, s) ((np)->offset + (np)->scale * \
 132                 noise2d_perlin((float)(x) * (np)->spread.X, (float)(y) * (np)->spread.Y, \
 133                 (s) + (np)->seed, (np)->octaves, (np)->persist))
 134
 135 #endif
 136