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