Don't ignore server disconnects in client code

[dragonfireclient.git] / src / noise.cpp

diff --git a/src/noise.cpp b/src/noise.cpp
index 8b84803b392ba014de32c5f184916e6c4a659975..2f4de6855ac0afb1331c9a818f3519fdc1b18cea 100644 (file)
--- a/src/noise.cpp
+++ b/src/noise.cpp
@@ -46,11 +46,6 @@ typedef float (*Interp3dFxn)(
                float v001, float v101, float v011, float v111,
                float x, float y, float z);
 
-float cos_lookup[16] = {
-       1.0f,  0.9238f,  0.7071f,  0.3826f, .0f, -0.3826f, -0.7071f, -0.9238f,
-       1.0f, -0.9238f, -0.7071f, -0.3826f, .0f,  0.3826f,  0.7071f,  0.9238f
-};
-
 FlagDesc flagdesc_noiseparams[] = {
        {"defaults",    NOISE_FLAG_DEFAULTS},
        {"eased",       NOISE_FLAG_EASED},
@@ -317,54 +312,9 @@ float noise2d_perlin(float x, float y, s32 seed,
 }
 
 
-float noise2d_perlin_abs(float x, float y, s32 seed,
-       int octaves, float persistence, bool eased)
-{
-       float a = 0;
-       float f = 1.0;
-       float g = 1.0;
-       for (int i = 0; i < octaves; i++) {
-               a += g * fabs(noise2d_gradient(x * f, y * f, seed + i, eased));
-               f *= 2.0;
-               g *= persistence;
-       }
-       return a;
-}
-
-
-float noise3d_perlin(float x, float y, float z, s32 seed,
-       int octaves, float persistence, bool eased)
-{
-       float a = 0;
-       float f = 1.0;
-       float g = 1.0;
-       for (int i = 0; i < octaves; i++) {
-               a += g * noise3d_gradient(x * f, y * f, z * f, seed + i, eased);
-               f *= 2.0;
-               g *= persistence;
-       }
-       return a;
-}
-
-
-float noise3d_perlin_abs(float x, float y, float z, s32 seed,
-       int octaves, float persistence, bool eased)
-{
-       float a = 0;
-       float f = 1.0;
-       float g = 1.0;
-       for (int i = 0; i < octaves; i++) {
-               a += g * fabs(noise3d_gradient(x * f, y * f, z * f, seed + i, eased));
-               f *= 2.0;
-               g *= persistence;
-       }
-       return a;
-}
-
-
 float contour(float v)
 {
-       v = fabs(v);
+       v = std::fabs(v);
        if (v >= 1.0)
                return 0.0;
        return (1.0 - v);
@@ -374,7 +324,7 @@ float contour(float v)
 ///////////////////////// [ New noise ] ////////////////////////////
 
 
-float NoisePerlin2D(NoiseParams *np, float x, float y, s32 seed)
+float NoisePerlin2D(const NoiseParams *np, float x, float y, s32 seed)
 {
        float a = 0;
        float f = 1.0;
@@ -389,7 +339,7 @@ float NoisePerlin2D(NoiseParams *np, float x, float y, s32 seed)
                        np->flags & (NOISE_FLAG_DEFAULTS | NOISE_FLAG_EASED));
 
                if (np->flags & NOISE_FLAG_ABSVALUE)
-                       noiseval = fabs(noiseval);
+                       noiseval = std::fabs(noiseval);
 
                a += g * noiseval;
                f *= np->lacunarity;
@@ -400,7 +350,7 @@ float NoisePerlin2D(NoiseParams *np, float x, float y, s32 seed)
 }
 
 
-float NoisePerlin3D(NoiseParams *np, float x, float y, float z, s32 seed)
+float NoisePerlin3D(const NoiseParams *np, float x, float y, float z, s32 seed)
 {
        float a = 0;
        float f = 1.0;
@@ -416,7 +366,7 @@ float NoisePerlin3D(NoiseParams *np, float x, float y, float z, s32 seed)
                        np->flags & NOISE_FLAG_EASED);
 
                if (np->flags & NOISE_FLAG_ABSVALUE)
-                       noiseval = fabs(noiseval);
+                       noiseval = std::fabs(noiseval);
 
                a += g * noiseval;
                f *= np->lacunarity;
@@ -427,9 +377,9 @@ float NoisePerlin3D(NoiseParams *np, float x, float y, float z, s32 seed)
 }
 
 
-Noise::Noise(NoiseParams *np_, s32 seed, u32 sx, u32 sy, u32 sz)
+Noise::Noise(const NoiseParams *np_, s32 seed, u32 sx, u32 sy, u32 sz)
 {
-       memcpy(&np, np_, sizeof(np));
+       np = *np_;
        this->seed = seed;
        this->sx   = sx;
        this->sy   = sy;
@@ -503,28 +453,37 @@ void Noise::setOctaves(int octaves)
 
 void Noise::resizeNoiseBuf(bool is3d)
 {
-       //maximum possible spread value factor
+       // Maximum possible spread value factor
        float ofactor = (np.lacunarity > 1.0) ?
                pow(np.lacunarity, np.octaves - 1) :
                np.lacunarity;
 
-       // noise lattice point count
+       // Noise lattice point count
        // (int)(sz * spread * ofactor) is # of lattice points crossed due to length
        float num_noise_points_x = sx * ofactor / np.spread.X;
        float num_noise_points_y = sy * ofactor / np.spread.Y;
        float num_noise_points_z = sz * ofactor / np.spread.Z;
 
-       // protect against obviously invalid parameters
+       // Protect against obviously invalid parameters
        if (num_noise_points_x > 1000000000.f ||
-               num_noise_points_y > 1000000000.f ||
-               num_noise_points_z > 1000000000.f)
+                       num_noise_points_y > 1000000000.f ||
+                       num_noise_points_z > 1000000000.f)
                throw InvalidNoiseParamsException();
 
+       // Protect against an octave having a spread < 1, causing broken noise values
+       if (np.spread.X / ofactor < 1.0f ||
+                       np.spread.Y / ofactor < 1.0f ||
+                       np.spread.Z / ofactor < 1.0f) {
+               errorstream << "A noise parameter has too many octaves: "
+                       << np.octaves << " octaves" << std::endl;
+               throw InvalidNoiseParamsException("A noise parameter has too many octaves");
+       }
+
        // + 2 for the two initial endpoints
        // + 1 for potentially crossing a boundary due to offset
-       size_t nlx = (size_t)ceil(num_noise_points_x) + 3;
-       size_t nly = (size_t)ceil(num_noise_points_y) + 3;
-       size_t nlz = is3d ? (size_t)ceil(num_noise_points_z) + 3 : 1;
+       size_t nlx = (size_t)std::ceil(num_noise_points_x) + 3;
+       size_t nly = (size_t)std::ceil(num_noise_points_y) + 3;
+       size_t nlz = is3d ? (size_t)std::ceil(num_noise_points_z) + 3 : 1;
 
        delete[] noise_buf;
        try {
@@ -561,8 +520,8 @@ void Noise::gradientMap2D(
        Interp2dFxn interpolate = eased ?
                biLinearInterpolation : biLinearInterpolationNoEase;
 
-       x0 = floor(x);
-       y0 = floor(y);
+       x0 = std::floor(x);
+       y0 = std::floor(y);
        u = x - (float)x0;
        v = y - (float)y0;
        orig_u = u;
@@ -626,9 +585,9 @@ void Noise::gradientMap3D(
        Interp3dFxn interpolate = (np.flags & NOISE_FLAG_EASED) ?
                triLinearInterpolation : triLinearInterpolationNoEase;
 
-       x0 = floor(x);
-       y0 = floor(y);
-       z0 = floor(z);
+       x0 = std::floor(x);
+       y0 = std::floor(y);
+       z0 = std::floor(z);
        u = x - (float)x0;
        v = y - (float)y0;
        w = z - (float)z0;
@@ -730,7 +689,7 @@ float *Noise::perlinMap2D(float x, float y, float *persistence_map)
                g *= np.persist;
        }
 
-       if (fabs(np.offset - 0.f) > 0.00001 || fabs(np.scale - 1.f) > 0.00001) {
+       if (std::fabs(np.offset - 0.f) > 0.00001 || std::fabs(np.scale - 1.f) > 0.00001) {
                for (size_t i = 0; i != bufsize; i++)
                        result[i] = result[i] * np.scale + np.offset;
        }
@@ -768,7 +727,7 @@ float *Noise::perlinMap3D(float x, float y, float z, float *persistence_map)
                g *= np.persist;
        }
 
-       if (fabs(np.offset - 0.f) > 0.00001 || fabs(np.scale - 1.f) > 0.00001) {
+       if (std::fabs(np.offset - 0.f) > 0.00001 || std::fabs(np.scale - 1.f) > 0.00001) {
                for (size_t i = 0; i != bufsize; i++)
                        result[i] = result[i] * np.scale + np.offset;
        }
@@ -785,12 +744,12 @@ void Noise::updateResults(float g, float *gmap,
        if (np.flags & NOISE_FLAG_ABSVALUE) {
                if (persistence_map) {
                        for (size_t i = 0; i != bufsize; i++) {
-                               result[i] += gmap[i] * fabs(gradient_buf[i]);
+                               result[i] += gmap[i] * std::fabs(gradient_buf[i]);
                                gmap[i] *= persistence_map[i];
                        }
                } else {
                        for (size_t i = 0; i != bufsize; i++)
-                               result[i] += g * fabs(gradient_buf[i]);
+                               result[i] += g * std::fabs(gradient_buf[i]);
                }
        } else {
                if (persistence_map) {