3 * Copyright (C) 2010-2014 celeron55, Perttu Ahola <celeron55@gmail.com>
4 * Copyright (C) 2010-2014 kwolekr, Ryan Kwolek <kwolekr@minetest.net>
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.
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.
30 #include "exceptions.h"
31 #include "util/string.h"
33 extern FlagDesc flagdesc_noiseparams[];
35 // Note: this class is not polymorphic so that its high level of
36 // optimizability may be preserved in the common use case
39 const static u32 RANDOM_RANGE = 32767;
41 inline PseudoRandom(int seed=0):
46 inline void seed(int seed)
53 m_next = m_next * 1103515245 + 12345;
54 return (unsigned)(m_next / 65536) % (RANDOM_RANGE + 1);
57 inline int range(int min, int max)
60 throw PrngException("Invalid range (max < min)");
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.
67 if ((u32)(max - min) > (RANDOM_RANGE + 1) / 10)
68 throw PrngException("Range too large");
70 return (next() % (max - min + 1)) + min;
79 const static s32 RANDOM_MIN = -0x7fffffff - 1;
80 const static s32 RANDOM_MAX = 0x7fffffff;
81 const static u32 RANDOM_RANGE = 0xffffffff;
83 PcgRandom(u64 state=0x853c49e6748fea9bULL, u64 seq=0xda3e39cb94b95bdbULL);
84 void seed(u64 state, u64 seq=0xda3e39cb94b95bdbULL);
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);
96 #define NOISE_FLAG_DEFAULTS 0x01
97 #define NOISE_FLAG_EASED 0x02
98 #define NOISE_FLAG_ABSVALUE 0x04
100 //// TODO(hmmmm): implement these!
101 #define NOISE_FLAG_POINTBUFFER 0x08
102 #define NOISE_FLAG_SIMPLEX 0x10
107 v3f spread = v3f(250, 250, 250);
110 float persist = 0.6f;
111 float lacunarity = 2.0f;
112 u32 flags = NOISE_FLAG_DEFAULTS;
116 NoiseParams(float offset_, float scale_, v3f spread_, s32 seed_,
117 u16 octaves_, float persist_, float lacunarity_,
118 u32 flags_=NOISE_FLAG_DEFAULTS)
126 lacunarity = lacunarity_;
138 float *noise_buf = nullptr;
139 float *gradient_buf = nullptr;
140 float *persist_buf = nullptr;
141 float *result = nullptr;
143 Noise(NoiseParams *np, s32 seed, u32 sx, u32 sy, u32 sz=1);
146 void setSize(u32 sx, u32 sy, u32 sz=1);
147 void setSpreadFactor(v3f spread);
148 void setOctaves(int octaves);
152 float step_x, float step_y,
155 float x, float y, float z,
156 float step_x, float step_y, float step_z,
159 float *perlinMap2D(float x, float y, float *persistence_map=NULL);
160 float *perlinMap3D(float x, float y, float z, float *persistence_map=NULL);
162 inline float *perlinMap2D_PO(float x, float xoff, float y, float yoff,
163 float *persistence_map=NULL)
166 x + xoff * np.spread.X,
167 y + yoff * np.spread.Y,
171 inline float *perlinMap3D_PO(float x, float xoff, float y, float yoff,
172 float z, float zoff, float *persistence_map=NULL)
175 x + xoff * np.spread.X,
176 y + yoff * np.spread.Y,
177 z + zoff * np.spread.Z,
183 void resizeNoiseBuf(bool is3d);
184 void updateResults(float g, float *gmap, float *persistence_map, size_t bufsize);
188 float NoisePerlin2D(NoiseParams *np, float x, float y, s32 seed);
189 float NoisePerlin3D(NoiseParams *np, float x, float y, float z, s32 seed);
191 inline float NoisePerlin2D_PO(NoiseParams *np, float x, float xoff,
192 float y, float yoff, s32 seed)
194 return NoisePerlin2D(np,
195 x + xoff * np->spread.X,
196 y + yoff * np->spread.Y,
200 inline float NoisePerlin3D_PO(NoiseParams *np, float x, float xoff,
201 float y, float yoff, float z, float zoff, s32 seed)
203 return NoisePerlin3D(np,
204 x + xoff * np->spread.X,
205 y + yoff * np->spread.Y,
206 z + zoff * np->spread.Z,
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);
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);
217 float noise2d_perlin(float x, float y, s32 seed,
218 int octaves, float persistence, bool eased=true);
220 float noise2d_perlin_abs(float x, float y, s32 seed,
221 int octaves, float persistence, bool eased=true);
223 float noise3d_perlin(float x, float y, float z, s32 seed,
224 int octaves, float persistence, bool eased=false);
226 float noise3d_perlin_abs(float x, float y, float z, s32 seed,
227 int octaves, float persistence, bool eased=false);
229 inline float easeCurve(float t)
231 return t * t * t * (t * (6.f * t - 15.f) + 10.f);
234 float contour(float v);