Fix some setting documentation

[dragonfireclient.git] / src / noise.cpp

diff --git a/src/noise.cpp b/src/noise.cpp
index 826593474a1f0e7fccb10986e5a5b3687ecbfffc..2ddc3926f56ca430a6010b06aa281010c24f4d89 100644 (file)
--- a/src/noise.cpp
+++ b/src/noise.cpp
@@ -90,23 +90,26 @@ u32 PcgRandom::next()
 
 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
+       to become a multiple of bound by dropping values above the a threshold.
+       In our example, threshold == 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.
        */
-       u32 threshhold = -bound % bound;
+       u32 threshold = -bound % bound;
        u32 r;
 
-       while ((r = next()) < threshhold)
+       while ((r = next()) < threshold)
                ;
 
        return r % bound;
@@ -138,7 +141,7 @@ void PcgRandom::bytes(void *out, size_t len)
                *outb = r & 0xFF;
                outb++;
                bytes_left--;
-               r >>= 8;
+               r >>= CHAR_BIT;
        }
 }
 
@@ -155,21 +158,21 @@ s32 PcgRandom::randNormalDist(s32 min, s32 max, int num_trials)
 
 float noise2d(int x, int y, int 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)
 {
-       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;
 }
 
 
@@ -192,14 +195,6 @@ inline float biLinearInterpolation(
 {
        float tx = easeCurve(x);
        float ty = easeCurve(y);
-#if 0
-       return (
-               v00 * (1 - tx) * (1 - ty) +
-               v10 *      tx  * (1 - ty) +
-               v01 * (1 - tx) *      ty  +
-               v11 *      tx  *      ty
-       );
-#endif
        float u = linearInterpolation(v00, v10, tx);
        float v = linearInterpolation(v01, v11, tx);
        return linearInterpolation(u, v, ty);
@@ -225,18 +220,6 @@ float triLinearInterpolation(
        float tx = easeCurve(x);
        float ty = easeCurve(y);
        float tz = easeCurve(z);
-#if 0
-       return (
-               v000 * (1 - tx) * (1 - ty) * (1 - tz) +
-               v100 *      tx  * (1 - ty) * (1 - tz) +
-               v010 * (1 - tx) *      ty  * (1 - tz) +
-               v110 *      tx  *      ty  * (1 - tz) +
-               v001 * (1 - tx) * (1 - ty) *      tz  +
-               v101 *      tx  * (1 - ty) *      tz  +
-               v011 * (1 - tx) *      ty  *      tz  +
-               v111 *      tx  *      ty  *      tz
-       );
-#endif
        float u = biLinearInterpolationNoEase(v000, v100, v010, v110, tx, ty);
        float v = biLinearInterpolationNoEase(v001, v101, v011, v111, tx, ty);
        return linearInterpolation(u, v, tz);
@@ -252,33 +235,6 @@ float triLinearInterpolationNoEase(
        return linearInterpolation(u, v, z);
 }
 
-
-#if 0
-float noise2d_gradient(float x, float y, int seed)
-{
-       // Calculate the integer coordinates
-       int x0 = (x > 0.0 ? (int)x : (int)x - 1);
-       int y0 = (y > 0.0 ? (int)y : (int)y - 1);
-       // Calculate the remaining part of the coordinates
-       float xl = x - (float)x0;
-       float yl = y - (float)y0;
-       // Calculate random cosine lookup table indices for the integer corners.
-       // They are looked up as unit vector gradients from the lookup table.
-       int n00 = (int)((noise2d(x0, y0, seed)+1)*8);
-       int n10 = (int)((noise2d(x0+1, y0, seed)+1)*8);
-       int n01 = (int)((noise2d(x0, y0+1, seed)+1)*8);
-       int n11 = (int)((noise2d(x0+1, y0+1, seed)+1)*8);
-       // Make a dot product for the gradients and the positions, to get the values
-       float s = dotProduct(cos_lookup[n00], cos_lookup[(n00+12)%16], xl, yl);
-       float u = dotProduct(-cos_lookup[n10], cos_lookup[(n10+12)%16], 1.-xl, yl);
-       float v = dotProduct(cos_lookup[n01], -cos_lookup[(n01+12)%16], xl, 1.-yl);
-       float w = dotProduct(-cos_lookup[n11], -cos_lookup[(n11+12)%16], 1.-xl, 1.-yl);
-       // Interpolate between the values
-       return biLinearInterpolation(s,u,v,w,xl,yl);
-}
-#endif
-
-
 float noise2d_gradient(float x, float y, int seed, bool eased)
 {
        // Calculate the integer coordinates