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.
29 #include "exceptions.h"
30 #include "util/string.h"
32 #if defined(RANDOM_MIN)
35 #if defined(RANDOM_MAX)
39 extern FlagDesc flagdesc_noiseparams[];
41 // Note: this class is not polymorphic so that its high level of
42 // optimizability may be preserved in the common use case
45 const static u32 RANDOM_RANGE = 32767;
47 inline PseudoRandom(int seed=0):
52 inline void seed(int seed)
59 m_next = m_next * 1103515245 + 12345;
60 return (unsigned)(m_next / 65536) % (RANDOM_RANGE + 1);
63 inline int range(int min, int max)
66 throw PrngException("Invalid range (max < min)");
68 Here, we ensure the range is not too large relative to RANDOM_MAX,
69 as otherwise the effects of bias would become noticable. Unlike
70 PcgRandom, we cannot modify this RNG's range as it would change the
71 output of this RNG for reverse compatibility.
73 if ((u32)(max - min) > (RANDOM_RANGE + 1) / 10)
74 throw PrngException("Range too large");
76 return (next() % (max - min + 1)) + min;
85 const static s32 RANDOM_MIN = -0x7fffffff - 1;
86 const static s32 RANDOM_MAX = 0x7fffffff;
87 const static u32 RANDOM_RANGE = 0xffffffff;
89 PcgRandom(u64 state=0x853c49e6748fea9bULL, u64 seq=0xda3e39cb94b95bdbULL);
90 void seed(u64 state, u64 seq=0xda3e39cb94b95bdbULL);
93 s32 range(s32 min, s32 max);
94 void bytes(void *out, size_t len);
95 s32 randNormalDist(s32 min, s32 max, int num_trials=6);
102 #define NOISE_FLAG_DEFAULTS 0x01
103 #define NOISE_FLAG_EASED 0x02
104 #define NOISE_FLAG_ABSVALUE 0x04
106 //// TODO(hmmmm): implement these!
107 #define NOISE_FLAG_POINTBUFFER 0x08
108 #define NOISE_FLAG_SIMPLEX 0x10
113 v3f spread = v3f(250, 250, 250);
116 float persist = 0.6f;
117 float lacunarity = 2.0f;
118 u32 flags = NOISE_FLAG_DEFAULTS;
120 NoiseParams() = default;
122 NoiseParams(float offset_, float scale_, const v3f &spread_, s32 seed_,
123 u16 octaves_, float persist_, float lacunarity_,
124 u32 flags_=NOISE_FLAG_DEFAULTS)
132 lacunarity = lacunarity_;
144 float *noise_buf = nullptr;
145 float *gradient_buf = nullptr;
146 float *persist_buf = nullptr;
147 float *result = nullptr;
149 Noise(NoiseParams *np, s32 seed, u32 sx, u32 sy, u32 sz=1);
152 void setSize(u32 sx, u32 sy, u32 sz=1);
153 void setSpreadFactor(v3f spread);
154 void setOctaves(int octaves);
158 float step_x, float step_y,
161 float x, float y, float z,
162 float step_x, float step_y, float step_z,
165 float *perlinMap2D(float x, float y, float *persistence_map=NULL);
166 float *perlinMap3D(float x, float y, float z, float *persistence_map=NULL);
168 inline float *perlinMap2D_PO(float x, float xoff, float y, float yoff,
169 float *persistence_map=NULL)
172 x + xoff * np.spread.X,
173 y + yoff * np.spread.Y,
177 inline float *perlinMap3D_PO(float x, float xoff, float y, float yoff,
178 float z, float zoff, float *persistence_map=NULL)
181 x + xoff * np.spread.X,
182 y + yoff * np.spread.Y,
183 z + zoff * np.spread.Z,
189 void resizeNoiseBuf(bool is3d);
190 void updateResults(float g, float *gmap, const float *persistence_map,
195 float NoisePerlin2D(NoiseParams *np, float x, float y, s32 seed);
196 float NoisePerlin3D(NoiseParams *np, float x, float y, float z, s32 seed);
198 inline float NoisePerlin2D_PO(NoiseParams *np, float x, float xoff,
199 float y, float yoff, s32 seed)
201 return NoisePerlin2D(np,
202 x + xoff * np->spread.X,
203 y + yoff * np->spread.Y,
207 inline float NoisePerlin3D_PO(NoiseParams *np, float x, float xoff,
208 float y, float yoff, float z, float zoff, s32 seed)
210 return NoisePerlin3D(np,
211 x + xoff * np->spread.X,
212 y + yoff * np->spread.Y,
213 z + zoff * np->spread.Z,
217 // Return value: -1 ... 1
218 float noise2d(int x, int y, s32 seed);
219 float noise3d(int x, int y, int z, s32 seed);
221 float noise2d_gradient(float x, float y, s32 seed, bool eased=true);
222 float noise3d_gradient(float x, float y, float z, s32 seed, bool eased=false);
224 float noise2d_perlin(float x, float y, s32 seed,
225 int octaves, float persistence, bool eased=true);
227 float noise2d_perlin_abs(float x, float y, s32 seed,
228 int octaves, float persistence, bool eased=true);
230 float noise3d_perlin(float x, float y, float z, s32 seed,
231 int octaves, float persistence, bool eased=false);
233 float noise3d_perlin_abs(float x, float y, float z, s32 seed,
234 int octaves, float persistence, bool eased=false);
236 inline float easeCurve(float t)
238 return t * t * t * (t * (6.f * t - 15.f) + 10.f);
241 float contour(float v);