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 #pragma once
27
28 #include "irr_v3d.h"
29 #include "exceptions.h"
30 #include "util/string.h"
31
32 #if defined(RANDOM_MIN)
33 #undef RANDOM_MIN
34 #endif
35 #if defined(RANDOM_MAX)
36 #undef RANDOM_MAX
37 #endif
38
39 extern FlagDesc flagdesc_noiseparams[];
40
41 // Note: this class is not polymorphic so that its high level of
42 // optimizability may be preserved in the common use case
43 class PseudoRandom {
44 public:
45 const static u32 RANDOM_RANGE = 32767;
46
47 inline PseudoRandom(int seed=0):
m_next(seed)48 m_next(seed)
49 {
50 }
51
seed(int seed)52 inline void seed(int seed)
53 {
54 m_next = seed;
55 }
56
next()57 inline int next()
58 {
59 m_next = m_next * 1103515245 + 12345;
60 return (unsigned)(m_next / 65536) % (RANDOM_RANGE + 1);
61 }
62
range(int min,int max)63 inline int range(int min, int max)
64 {
65 if (max < min)
66 throw PrngException("Invalid range (max < min)");
67 /*
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.
72 */
73 if ((u32)(max - min) > (RANDOM_RANGE + 1) / 10)
74 throw PrngException("Range too large");
75
76 return (next() % (max - min + 1)) + min;
77 }
78
79 private:
80 int m_next;
81 };
82
83 class PcgRandom {
84 public:
85 const static s32 RANDOM_MIN = -0x7fffffff - 1;
86 const static s32 RANDOM_MAX = 0x7fffffff;
87 const static u32 RANDOM_RANGE = 0xffffffff;
88
89 PcgRandom(u64 state=0x853c49e6748fea9bULL, u64 seq=0xda3e39cb94b95bdbULL);
90 void seed(u64 state, u64 seq=0xda3e39cb94b95bdbULL);
91 u32 next();
92 u32 range(u32 bound);
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);
96
97 private:
98 u64 m_state;
99 u64 m_inc;
100 };
101
102 #define NOISE_FLAG_DEFAULTS 0x01
103 #define NOISE_FLAG_EASED 0x02
104 #define NOISE_FLAG_ABSVALUE 0x04
105
106 //// TODO(hmmmm): implement these!
107 #define NOISE_FLAG_POINTBUFFER 0x08
108 #define NOISE_FLAG_SIMPLEX 0x10
109
110 struct NoiseParams {
111 float offset = 0.0f;
112 float scale = 1.0f;
113 v3f spread = v3f(250, 250, 250);
114 s32 seed = 12345;
115 u16 octaves = 3;
116 float persist = 0.6f;
117 float lacunarity = 2.0f;
118 u32 flags = NOISE_FLAG_DEFAULTS;
119
120 NoiseParams() = default;
121
122 NoiseParams(float offset_, float scale_, const v3f &spread_, s32 seed_,
123 u16 octaves_, float persist_, float lacunarity_,
124 u32 flags_=NOISE_FLAG_DEFAULTS)
125 {
126 offset = offset_;
127 scale = scale_;
128 spread = spread_;
129 seed = seed_;
130 octaves = octaves_;
131 persist = persist_;
132 lacunarity = lacunarity_;
133 flags = flags_;
134 }
135 };
136
137 class Noise {
138 public:
139 NoiseParams np;
140 s32 seed;
141 u32 sx;
142 u32 sy;
143 u32 sz;
144 float *noise_buf = nullptr;
145 float *gradient_buf = nullptr;
146 float *persist_buf = nullptr;
147 float *result = nullptr;
148
149 Noise(NoiseParams *np, s32 seed, u32 sx, u32 sy, u32 sz=1);
150 ~Noise();
151
152 void setSize(u32 sx, u32 sy, u32 sz=1);
153 void setSpreadFactor(v3f spread);
154 void setOctaves(int octaves);
155
156 void gradientMap2D(
157 float x, float y,
158 float step_x, float step_y,
159 s32 seed);
160 void gradientMap3D(
161 float x, float y, float z,
162 float step_x, float step_y, float step_z,
163 s32 seed);
164
165 float *perlinMap2D(float x, float y, float *persistence_map=NULL);
166 float *perlinMap3D(float x, float y, float z, float *persistence_map=NULL);
167
168 inline float *perlinMap2D_PO(float x, float xoff, float y, float yoff,
169 float *persistence_map=NULL)
170 {
171 return perlinMap2D(
172 x + xoff * np.spread.X,
173 y + yoff * np.spread.Y,
174 persistence_map);
175 }
176
177 inline float *perlinMap3D_PO(float x, float xoff, float y, float yoff,
178 float z, float zoff, float *persistence_map=NULL)
179 {
180 return perlinMap3D(
181 x + xoff * np.spread.X,
182 y + yoff * np.spread.Y,
183 z + zoff * np.spread.Z,
184 persistence_map);
185 }
186
187 private:
188 void allocBuffers();
189 void resizeNoiseBuf(bool is3d);
190 void updateResults(float g, float *gmap, const float *persistence_map,
191 size_t bufsize);
192
193 };
194
195 float NoisePerlin2D(NoiseParams *np, float x, float y, s32 seed);
196 float NoisePerlin3D(NoiseParams *np, float x, float y, float z, s32 seed);
197
NoisePerlin2D_PO(NoiseParams * np,float x,float xoff,float y,float yoff,s32 seed)198 inline float NoisePerlin2D_PO(NoiseParams *np, float x, float xoff,
199 float y, float yoff, s32 seed)
200 {
201 return NoisePerlin2D(np,
202 x + xoff * np->spread.X,
203 y + yoff * np->spread.Y,
204 seed);
205 }
206
NoisePerlin3D_PO(NoiseParams * np,float x,float xoff,float y,float yoff,float z,float zoff,s32 seed)207 inline float NoisePerlin3D_PO(NoiseParams *np, float x, float xoff,
208 float y, float yoff, float z, float zoff, s32 seed)
209 {
210 return NoisePerlin3D(np,
211 x + xoff * np->spread.X,
212 y + yoff * np->spread.Y,
213 z + zoff * np->spread.Z,
214 seed);
215 }
216
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);
220
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);
223
224 float noise2d_perlin(float x, float y, s32 seed,
225 int octaves, float persistence, bool eased=true);
226
227 float noise2d_perlin_abs(float x, float y, s32 seed,
228 int octaves, float persistence, bool eased=true);
229
230 float noise3d_perlin(float x, float y, float z, s32 seed,
231 int octaves, float persistence, bool eased=false);
232
233 float noise3d_perlin_abs(float x, float y, float z, s32 seed,
234 int octaves, float persistence, bool eased=false);
235
easeCurve(float t)236 inline float easeCurve(float t)
237 {
238 return t * t * t * (t * (6.f * t - 15.f) + 10.f);
239 }
240
241 float contour(float v);
242