Decorations: Generalise 'spawn by' to be used by all decoration types

[minetest.git] / src / noise.cpp

diff --git a/src/noise.cpp b/src/noise.cpp
index 2948fb765c509fb424fec0496f27b53e1d641d4c..b918c9936851ccb638dcf617f1cc6c8ef9dc34fd 100644 (file)
--- a/src/noise.cpp
+++ b/src/noise.cpp
@@ -93,23 +93,32 @@ u32 PcgRandom::range(u32 bound)
        // If the bound is 0, we cover the whole RNG's range
        if (bound == 0)
                return next();
+
        /*
-       If the bound is not a multiple of the RNG's range, it may cause bias,
-       e.g. a RNG has a range from 0 to 3 and we take want a number 0 to 2.
-       Using rand() % 3, the number 0 would be twice as likely to appear.
-       With a very large RNG range, the effect becomes less prevalent but
-       still present.  This can be solved by modifying the range of the RNG
-       to become a multiple of bound by dropping values above the a threshhold.
-       In our example, threshhold == 4 - 3 = 1 % 3 == 1, so reject 0, thus
-       making the range 3 with no bias.
-
-       This loop looks dangerous, but will always terminate due to the
-       RNG's property of uniformity.
+               This is an optimization of the expression:
+                 0x100000000ull % bound
+               since 64-bit modulo operations typically much slower than 32.
        */
-       u32 threshhold = -bound % bound;
+       u32 threshold = -bound % bound;
        u32 r;
 
-       while ((r = next()) < threshhold)
+       /*
+               If the bound is not a multiple of the RNG's range, it may cause bias,
+               e.g. a RNG has a range from 0 to 3 and we take want a number 0 to 2.
+               Using rand() % 3, the number 0 would be twice as likely to appear.
+               With a very large RNG range, the effect becomes less prevalent but
+               still present.
+
+               This can be solved by modifying the range of the RNG to become a
+               multiple of bound by dropping values above the a threshold.
+
+               In our example, threshold == 4 % 3 == 1, so reject values < 1
+               (that is, 0), thus making the range == 3 with no bias.
+
+               This loop may look dangerous, but will always terminate due to the
+               RNG's property of uniformity.
+       */
+       while ((r = next()) < threshold)
                ;
 
        return r % bound;
@@ -156,23 +165,23 @@ s32 PcgRandom::randNormalDist(s32 min, s32 max, int num_trials)
 
 ///////////////////////////////////////////////////////////////////////////////
 
-float noise2d(int x, int y, int seed)
+float noise2d(int x, int y, s32 seed)
 {
-       int n = (NOISE_MAGIC_X * x + NOISE_MAGIC_Y * y
+       unsigned int n = (NOISE_MAGIC_X * x + NOISE_MAGIC_Y * y
                        + NOISE_MAGIC_SEED * seed) & 0x7fffffff;
        n = (n >> 13) ^ n;
        n = (n * (n * n * 60493 + 19990303) + 1376312589) & 0x7fffffff;
-       return 1.f - (float)n / 0x40000000;
+       return 1.f - (float)(int)n / 0x40000000;
 }
 
 
-float noise3d(int x, int y, int z, int seed)
+float noise3d(int x, int y, int z, s32 seed)
 {
-       int n = (NOISE_MAGIC_X * x + NOISE_MAGIC_Y * y + NOISE_MAGIC_Z * z
+       unsigned int n = (NOISE_MAGIC_X * x + NOISE_MAGIC_Y * y + NOISE_MAGIC_Z * z
                        + NOISE_MAGIC_SEED * seed) & 0x7fffffff;
        n = (n >> 13) ^ n;
        n = (n * (n * n * 60493 + 19990303) + 1376312589) & 0x7fffffff;
-       return 1.f - (float)n / 0x40000000;
+       return 1.f - (float)(int)n / 0x40000000;
 }
 
 
@@ -235,7 +244,7 @@ float triLinearInterpolationNoEase(
        return linearInterpolation(u, v, z);
 }
 
-float noise2d_gradient(float x, float y, int seed, bool eased)
+float noise2d_gradient(float x, float y, s32 seed, bool eased)
 {
        // Calculate the integer coordinates
        int x0 = myfloor(x);
@@ -256,7 +265,7 @@ float noise2d_gradient(float x, float y, int seed, bool eased)
 }
 
 
-float noise3d_gradient(float x, float y, float z, int seed, bool eased)
+float noise3d_gradient(float x, float y, float z, s32 seed, bool eased)
 {
        // Calculate the integer coordinates
        int x0 = myfloor(x);
@@ -290,7 +299,7 @@ float noise3d_gradient(float x, float y, float z, int seed, bool eased)
 }
 
 
-float noise2d_perlin(float x, float y, int seed,
+float noise2d_perlin(float x, float y, s32 seed,
        int octaves, float persistence, bool eased)
 {
        float a = 0;
@@ -306,7 +315,7 @@ float noise2d_perlin(float x, float y, int seed,
 }
 
 
-float noise2d_perlin_abs(float x, float y, int seed,
+float noise2d_perlin_abs(float x, float y, s32 seed,
        int octaves, float persistence, bool eased)
 {
        float a = 0;
@@ -321,7 +330,7 @@ float noise2d_perlin_abs(float x, float y, int seed,
 }
 
 
-float noise3d_perlin(float x, float y, float z, int seed,
+float noise3d_perlin(float x, float y, float z, s32 seed,
        int octaves, float persistence, bool eased)
 {
        float a = 0;
@@ -336,7 +345,7 @@ float noise3d_perlin(float x, float y, float z, int seed,
 }
 
 
-float noise3d_perlin_abs(float x, float y, float z, int seed,
+float noise3d_perlin_abs(float x, float y, float z, s32 seed,
        int octaves, float persistence, bool eased)
 {
        float a = 0;
@@ -363,7 +372,7 @@ float contour(float v)
 ///////////////////////// [ New noise ] ////////////////////////////
 
 
-float NoisePerlin2D(NoiseParams *np, float x, float y, int seed)
+float NoisePerlin2D(NoiseParams *np, float x, float y, s32 seed)
 {
        float a = 0;
        float f = 1.0;
@@ -389,7 +398,7 @@ float NoisePerlin2D(NoiseParams *np, float x, float y, int seed)
 }
 
 
-float NoisePerlin3D(NoiseParams *np, float x, float y, float z, int seed)
+float NoisePerlin3D(NoiseParams *np, float x, float y, float z, s32 seed)
 {
        float a = 0;
        float f = 1.0;
@@ -416,7 +425,7 @@ float NoisePerlin3D(NoiseParams *np, float x, float y, float z, int seed)
 }
 
 
-Noise::Noise(NoiseParams *np_, int seed, u32 sx, u32 sy, u32 sz)
+Noise::Noise(NoiseParams *np_, s32 seed, u32 sx, u32 sy, u32 sz)
 {
        memcpy(&np, np_, sizeof(np));
        this->seed = seed;
@@ -543,7 +552,7 @@ void Noise::resizeNoiseBuf(bool is3d)
 void Noise::gradientMap2D(
                float x, float y,
                float step_x, float step_y,
-               int seed)
+               s32 seed)
 {
        float v00, v01, v10, v11, u, v, orig_u;
        u32 index, i, j, noisex, noisey;
@@ -607,7 +616,7 @@ void Noise::gradientMap2D(
 void Noise::gradientMap3D(
                float x, float y, float z,
                float step_x, float step_y, float step_z,
-               int seed)
+               s32 seed)
 {
        float v000, v010, v100, v110;
        float v001, v011, v101, v111;