X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fnoise.h;h=ee8efea8306dde1d0eeb1925ccc634cbf72fe825;hb=9ef3c8ce388011f4f57adc9a7eb0326376aec750;hp=ace6d7eb4cb714e48c5aa40fa3e022f522e89c63;hpb=feb7de91ec34ef1ca3152270a7bc62b2e308f1bd;p=minetest.git diff --git a/src/noise.h b/src/noise.h index ace6d7eb4..ee8efea83 100644 --- a/src/noise.h +++ b/src/noise.h @@ -1,166 +1,232 @@ /* -Minetest -Copyright (C) 2010-2013 celeron55, Perttu Ahola -Copyright (C) 2010-2013 kwolekr, Ryan Kwolek + * Minetest + * Copyright (C) 2010-2014 celeron55, Perttu Ahola + * Copyright (C) 2010-2014 kwolekr, Ryan Kwolek + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are + * permitted provided that the following conditions are met: + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#pragma once -This program is free software; you can redistribute it and/or modify -it under the terms of the GNU Lesser General Public License as published by -the Free Software Foundation; either version 2.1 of the License, or -(at your option) any later version. - -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU Lesser General Public License for more details. - -You should have received a copy of the GNU Lesser General Public License along -with this program; if not, write to the Free Software Foundation, Inc., -51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. -*/ +#include "irr_v3d.h" +#include "exceptions.h" +#include "util/string.h" -#ifndef NOISE_HEADER -#define NOISE_HEADER +#if defined(RANDOM_MIN) +#undef RANDOM_MIN +#endif +#if defined(RANDOM_MAX) +#undef RANDOM_MAX +#endif -#include "debug.h" -#include "irr_v3d.h" +extern FlagDesc flagdesc_noiseparams[]; -class PseudoRandom -{ +// Note: this class is not polymorphic so that its high level of +// optimizability may be preserved in the common use case +class PseudoRandom { public: - PseudoRandom(): m_next(0) - { - } - PseudoRandom(int seed): m_next(seed) + const static u32 RANDOM_RANGE = 32767; + + inline PseudoRandom(int seed=0): + m_next(seed) { } - void seed(int seed) + + inline void seed(int seed) { m_next = seed; } - // Returns 0...32767 - int next() + + inline int next() { m_next = m_next * 1103515245 + 12345; - return((unsigned)(m_next/65536) % 32768); + return (unsigned)(m_next / 65536) % (RANDOM_RANGE + 1); } - int range(int min, int max) + + inline int range(int min, int max) { - if(max-min > 32768/10) - { - //dstream<<"WARNING: PseudoRandom::range: max > 32767"< max) - { - assert(0); - return max; - } - return (next()%(max-min+1))+min; + if (max < min) + throw PrngException("Invalid range (max < min)"); + /* + Here, we ensure the range is not too large relative to RANDOM_MAX, + as otherwise the effects of bias would become noticeable. Unlike + PcgRandom, we cannot modify this RNG's range as it would change the + output of this RNG for reverse compatibility. + */ + if ((u32)(max - min) > (RANDOM_RANGE + 1) / 10) + throw PrngException("Range too large"); + + return (next() % (max - min + 1)) + min; } + private: int m_next; }; -struct NoiseParams { - float offset; - float scale; - v3f spread; - int seed; - int octaves; - float persist; +class PcgRandom { +public: + const static s32 RANDOM_MIN = -0x7fffffff - 1; + const static s32 RANDOM_MAX = 0x7fffffff; + const static u32 RANDOM_RANGE = 0xffffffff; + + PcgRandom(u64 state=0x853c49e6748fea9bULL, u64 seq=0xda3e39cb94b95bdbULL); + void seed(u64 state, u64 seq=0xda3e39cb94b95bdbULL); + u32 next(); + u32 range(u32 bound); + s32 range(s32 min, s32 max); + void bytes(void *out, size_t len); + s32 randNormalDist(s32 min, s32 max, int num_trials=6); + +private: + u64 m_state; + u64 m_inc; }; +#define NOISE_FLAG_DEFAULTS 0x01 +#define NOISE_FLAG_EASED 0x02 +#define NOISE_FLAG_ABSVALUE 0x04 -// Convenience macros for getting/setting NoiseParams in Settings -#define getNoiseParams(x) getStruct((x), "f,f,v3,s32,s32,f") -#define setNoiseParams(x, y) setStruct((x), "f,f,v3,s32,s32,f", (y)) +//// TODO(hmmmm): implement these! +#define NOISE_FLAG_POINTBUFFER 0x08 +#define NOISE_FLAG_SIMPLEX 0x10 + +struct NoiseParams { + float offset = 0.0f; + float scale = 1.0f; + v3f spread = v3f(250, 250, 250); + s32 seed = 12345; + u16 octaves = 3; + float persist = 0.6f; + float lacunarity = 2.0f; + u32 flags = NOISE_FLAG_DEFAULTS; + + NoiseParams() = default; + + NoiseParams(float offset_, float scale_, const v3f &spread_, s32 seed_, + u16 octaves_, float persist_, float lacunarity_, + u32 flags_=NOISE_FLAG_DEFAULTS) + { + offset = offset_; + scale = scale_; + spread = spread_; + seed = seed_; + octaves = octaves_; + persist = persist_; + lacunarity = lacunarity_; + flags = flags_; + } +}; class Noise { public: - NoiseParams *np; - int seed; - int sx; - int sy; - int sz; - float *noisebuf; - float *buf; - float *result; - - Noise(NoiseParams *np, int seed, int sx, int sy); - Noise(NoiseParams *np, int seed, int sx, int sy, int sz); + NoiseParams np; + s32 seed; + u32 sx; + u32 sy; + u32 sz; + float *noise_buf = nullptr; + float *gradient_buf = nullptr; + float *persist_buf = nullptr; + float *result = nullptr; + + Noise(const NoiseParams *np, s32 seed, u32 sx, u32 sy, u32 sz=1); ~Noise(); - virtual void init(NoiseParams *np, int seed, int sx, int sy, int sz); - void setSize(int sx, int sy); - void setSize(int sx, int sy, int sz); + void setSize(u32 sx, u32 sy, u32 sz=1); void setSpreadFactor(v3f spread); void setOctaves(int octaves); - void resizeNoiseBuf(bool is3d); void gradientMap2D( float x, float y, float step_x, float step_y, - int seed); + s32 seed); void gradientMap3D( float x, float y, float z, float step_x, float step_y, float step_z, - int seed); - float *perlinMap2D(float x, float y); - float *perlinMap2DModulated(float x, float y, float *persist_map); - float *perlinMap3D(float x, float y, float z); - void transformNoiseMap(); -}; + s32 seed); -// Return value: -1 ... 1 -float noise2d(int x, int y, int seed); -float noise3d(int x, int y, int z, int seed); + float *perlinMap2D(float x, float y, float *persistence_map=NULL); + float *perlinMap3D(float x, float y, float z, float *persistence_map=NULL); -float noise2d_gradient(float x, float y, int seed); -float noise3d_gradient(float x, float y, float z, int seed); + inline float *perlinMap2D_PO(float x, float xoff, float y, float yoff, + float *persistence_map=NULL) + { + return perlinMap2D( + x + xoff * np.spread.X, + y + yoff * np.spread.Y, + persistence_map); + } -float noise2d_perlin(float x, float y, int seed, - int octaves, float persistence); + inline float *perlinMap3D_PO(float x, float xoff, float y, float yoff, + float z, float zoff, float *persistence_map=NULL) + { + return perlinMap3D( + x + xoff * np.spread.X, + y + yoff * np.spread.Y, + z + zoff * np.spread.Z, + persistence_map); + } -float noise2d_perlin_abs(float x, float y, int seed, - int octaves, float persistence); +private: + void allocBuffers(); + void resizeNoiseBuf(bool is3d); + void updateResults(float g, float *gmap, const float *persistence_map, + size_t bufsize); -float noise3d_perlin(float x, float y, float z, int seed, - int octaves, float persistence); +}; -float noise3d_perlin_abs(float x, float y, float z, int seed, - int octaves, float persistence); +float NoisePerlin2D(const NoiseParams *np, float x, float y, s32 seed); +float NoisePerlin3D(const NoiseParams *np, float x, float y, float z, s32 seed); -inline float easeCurve(float t) { - return t * t * t * (t * (6.f * t - 15.f) + 10.f); +inline float NoisePerlin2D_PO(NoiseParams *np, float x, float xoff, + float y, float yoff, s32 seed) +{ + return NoisePerlin2D(np, + x + xoff * np->spread.X, + y + yoff * np->spread.Y, + seed); +} + +inline float NoisePerlin3D_PO(NoiseParams *np, float x, float xoff, + float y, float yoff, float z, float zoff, s32 seed) +{ + return NoisePerlin3D(np, + x + xoff * np->spread.X, + y + yoff * np->spread.Y, + z + zoff * np->spread.Z, + seed); } -#define NoisePerlin2D(np, x, y, s) \ - ((np)->offset + (np)->scale * noise2d_perlin( \ - (float)(x) / (np)->spread.X, \ - (float)(y) / (np)->spread.Y, \ - (s) + (np)->seed, (np)->octaves, (np)->persist)) - -#define NoisePerlin2DNoTxfm(np, x, y, s) \ - (noise2d_perlin( \ - (float)(x) / (np)->spread.X, \ - (float)(y) / (np)->spread.Y, \ - (s) + (np)->seed, (np)->octaves, (np)->persist)) - -#define NoisePerlin2DPosOffset(np, x, xoff, y, yoff, s) \ - ((np)->offset + (np)->scale * noise2d_perlin( \ - (float)(xoff) + (float)(x) / (np)->spread.X, \ - (float)(yoff) + (float)(y) / (np)->spread.Y, \ - (s) + (np)->seed, (np)->octaves, (np)->persist)) - -#define NoisePerlin2DNoTxfmPosOffset(np, x, xoff, y, yoff, s) \ - (noise2d_perlin( \ - (float)(xoff) + (float)(x) / (np)->spread.X, \ - (float)(yoff) + (float)(y) / (np)->spread.Y, \ - (s) + (np)->seed, (np)->octaves, (np)->persist)) - -#define NoisePerlin3D(np, x, y, z, s) ((np)->offset + (np)->scale * \ - noise3d_perlin((float)(x) / (np)->spread.X, (float)(y) / (np)->spread.Y, \ - (float)(z) / (np)->spread.Z, (s) + (np)->seed, (np)->octaves, (np)->persist)) +// Return value: -1 ... 1 +float noise2d(int x, int y, s32 seed); +float noise3d(int x, int y, int z, s32 seed); -#endif +float noise2d_gradient(float x, float y, s32 seed, bool eased=true); +float noise3d_gradient(float x, float y, float z, s32 seed, bool eased=false); + +float noise2d_perlin(float x, float y, s32 seed, + int octaves, float persistence, bool eased=true); + +inline float easeCurve(float t) +{ + return t * t * t * (t * (6.f * t - 15.f) + 10.f); +} +float contour(float v);