Cleanup: Remove more #if 0 blocks
[blender.git] / source / blender / blenlib / intern / noise.c
index 6e52145..8ee9954 100644 (file)
  *  \ingroup bli
  */
 
-
-#ifdef _MSC_VER
-#  pragma warning (disable:4244)  /* "conversion from double to float" */
-#  pragma warning (disable:4305)  /* "truncation from const double to float" */
-#endif
-
 #include <math.h>
 
 #include "BLI_noise.h"
 
 /* local */
 static float noise3_perlin(float vec[3]);
-//static float turbulence_perlin(float *point, float lofreq, float hifreq);
+//static float turbulence_perlin(const float point[3], float lofreq, float hifreq);
 //static float turbulencep(float noisesize, float x, float y, float z, int nr);
 
 /* UNUSED */
@@ -50,7 +44,7 @@ static float noise3_perlin(float vec[3]);
 
 /* needed for voronoi */
 #define HASHPNT(x, y, z) hashpntf + 3 * hash[(hash[(hash[(z) & 255] + (y)) & 255] + (x)) & 255]
-static float hashpntf[768] = {
+static const float hashpntf[768] = {
        0.536902, 0.020915, 0.501445, 0.216316, 0.517036, 0.822466, 0.965315,
        0.377313, 0.678764, 0.744545, 0.097731, 0.396357, 0.247202, 0.520897,
        0.613396, 0.542124, 0.146813, 0.255489, 0.810868, 0.638641, 0.980742,
@@ -163,7 +157,7 @@ static float hashpntf[768] = {
        0.114246, 0.905043, 0.713870, 0.555261, 0.951333
 };
 
-unsigned char hash[512] = {
+const unsigned char hash[512] = {
        0xA2, 0xA0, 0x19, 0x3B, 0xF8, 0xEB, 0xAA, 0xEE, 0xF3, 0x1C, 0x67, 0x28, 0x1D, 0xED, 0x0,  0xDE, 0x95, 0x2E, 0xDC,
        0x3F, 0x3A, 0x82, 0x35, 0x4D, 0x6C, 0xBA, 0x36, 0xD0, 0xF6, 0xC,  0x79, 0x32, 0xD1, 0x59, 0xF4, 0x8,  0x8B, 0x63,
        0x89, 0x2F, 0xB8, 0xB4, 0x97, 0x83, 0xF2, 0x8F, 0x18, 0xC7, 0x51, 0x14, 0x65, 0x87, 0x48, 0x20, 0x42, 0xA8, 0x80,
@@ -194,7 +188,7 @@ unsigned char hash[512] = {
 };
 
 
-float hashvectf[768] = {
+const float hashvectf[768] = {
        0.33783, 0.715698, -0.611206, -0.944031, -0.326599, -0.045624, -0.101074, -0.416443, -0.903503, 0.799286, 0.49411,
        -0.341949, -0.854645, 0.518036, 0.033936, 0.42514, -0.437866, -0.792114, -0.358948, 0.597046, 0.717377, -0.985413,
        0.144714, 0.089294, -0.601776, -0.33728, -0.723907, -0.449921, 0.594513, 0.666382, 0.208313, -0.10791, 0.972076,
@@ -284,8 +278,8 @@ static float npfade(float t)
 static float grad(int hash_val, float x, float y, float z)
 {
        int h = hash_val & 15;                 /* CONVERT LO 4 BITS OF HASH CODE */
-       float u = h < 8 ? x : y,               /* INTO 12 GRADIENT DIRECTIONS. */
-             v = h < 4 ? y : h == 12 || h == 14 ? x : z;
+       float u = h < 8 ? x : y;               /* INTO 12 GRADIENT DIRECTIONS. */
+       float v = h < 4 ? y : h == 12 || h == 14 ? x : z;
        return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
 }
 
@@ -327,7 +321,8 @@ static float newPerlinU(float x, float y, float z)
 /* Was BLI_hnoise(), removed noisesize, so other functions can call it without scaling. */
 static float orgBlenderNoise(float x, float y, float z)
 {
-       register float cn1, cn2, cn3, cn4, cn5, cn6, i, *h;
+       register float cn1, cn2, cn3, cn4, cn5, cn6, i;
+       register const float *h;
        float fx, fy, fz, ox, oy, oz, jx, jy, jz;
        float n = 0.5;
        int ix, iy, iz, b00, b01, b10, b11, b20, b21;
@@ -426,9 +421,9 @@ float BLI_turbulence(float noisesize, float x, float y, float z, int nr)
        float s, d = 0.5, div = 1.0;
 
        s = BLI_hnoise(noisesize, x, y, z);
-       
+
        while (nr > 0) {
-       
+
                s += d * BLI_hnoise(noisesize * d, x, y, z);
                div += d;
                d *= 0.5f;
@@ -443,13 +438,13 @@ float BLI_turbulence1(float noisesize, float x, float y, float z, int nr)
        float s, d = 0.5, div = 1.0;
 
        s = fabsf((-1.0f + 2.0f * BLI_hnoise(noisesize, x, y, z)));
-       
+
        while (nr > 0) {
-       
+
                s += fabsf(d * (-1.0f + 2.0f * BLI_hnoise(noisesize * d, x, y, z)));
                div += d;
                d *= 0.5f;
-               
+
                nr--;
        }
        return s / div;
@@ -457,7 +452,7 @@ float BLI_turbulence1(float noisesize, float x, float y, float z, int nr)
 
 /* ********************* FROM PERLIN HIMSELF: ******************** */
 
-static const char p[512 + 2] = {
+static const char g_perlin_data_ub[512 + 2] = {
        0xA2, 0xA0, 0x19, 0x3B, 0xF8, 0xEB, 0xAA, 0xEE, 0xF3, 0x1C, 0x67, 0x28,
        0x1D, 0xED, 0x0,  0xDE, 0x95, 0x2E, 0xDC, 0x3F, 0x3A, 0x82, 0x35, 0x4D,
        0x6C, 0xBA, 0x36, 0xD0, 0xF6, 0xC,  0x79, 0x32, 0xD1, 0x59, 0xF4, 0x8,
@@ -504,7 +499,7 @@ static const char p[512 + 2] = {
 };
 
 
-static float g[512 + 2][3] = {
+static const float g_perlin_data_v3[512 + 2][3] = {
        {0.33783, 0.715698, -0.611206},
        {-0.944031, -0.326599, -0.045624},
        {-0.101074, -0.416443, -0.903503},
@@ -1033,8 +1028,11 @@ static float g[512 + 2][3] = {
 
 static float noise3_perlin(float vec[3])
 {
+       const char *p       = g_perlin_data_ub;
+       const float (*g)[3] = g_perlin_data_v3;
        int bx0, bx1, by0, by1, bz0, bz1, b00, b10, b01, b11;
-       float rx0, rx1, ry0, ry1, rz0, rz1, *q, sx, sy, sz, a, b, c, d, t, u, v;
+       float rx0, rx1, ry0, ry1, rz0, rz1, sx, sy, sz, a, b, c, d, t, u, v;
+       const float *q;
        register int i, j;
 
 
@@ -1050,8 +1048,8 @@ static float noise3_perlin(float vec[3])
        b01 = p[i + by1];
        b11 = p[j + by1];
 
-#define VALUE_AT(rx, ry, rz) (rx * q[0] + ry * q[1] + rz * q[2])
-#define SURVE(t) (t * t * (3.0f - 2.0f * t))
+#define VALUE_AT(rx, ry, rz) ((rx) * q[0] + (ry) * q[1] + (rz) * q[2])
+#define SURVE(t) ((t) * (t) * (3.0f - 2.0f * (t)))
 
 /* lerp moved to improved perlin above */
 
@@ -1094,26 +1092,6 @@ static float noise3_perlin(float vec[3])
 #undef SURVE
 }
 
-#if 0
-static float turbulence_perlin(float *point, float lofreq, float hifreq)
-{
-       float freq, t, p[3];
-
-       p[0] = point[0] + 123.456;
-       p[1] = point[1];
-       p[2] = point[2];
-
-       t = 0;
-       for (freq = lofreq; freq < hifreq; freq *= 2.0) {
-               t += fabsf(noise3_perlin(p)) / freq;
-               p[0] *= 2.0f;
-               p[1] *= 2.0f;
-               p[2] *= 2.0f;
-       }
-       return t - 0.3; /* readjust to make mean value = 0.0 */
-}
-#endif
-
 /* for use with BLI_gNoise/gTurbulence, returns signed noise */
 static float orgPerlinNoise(float x, float y, float z)
 {
@@ -1149,19 +1127,6 @@ float BLI_hnoisep(float noisesize, float x, float y, float z)
        return noise3_perlin(vec);
 }
 
-#if 0
-static float turbulencep(float noisesize, float x, float y, float z, int nr)
-{
-       float vec[3];
-
-       vec[0] = x / noisesize;
-       vec[1] = y / noisesize;
-       vec[2] = z / noisesize;
-       nr++;
-       return turbulence_perlin(vec, 1.0, (float)(1 << nr));
-}
-#endif
-
 /******************/
 /* VORONOI/WORLEY */
 /******************/
@@ -1227,7 +1192,7 @@ static float dist_Minkovsky(float x, float y, float z, float e)
 void voronoi(float x, float y, float z, float *da, float *pa, float me, int dtype)
 {
        int xx, yy, zz, xi, yi, zi;
-       float xd, yd, zd, d, *p;
+       float xd, yd, zd, d;
 
        float (*distfunc)(float, float, float, float);
        switch (dtype) {
@@ -1252,6 +1217,7 @@ void voronoi(float x, float y, float z, float *da, float *pa, float me, int dtyp
                case 0:
                default:
                        distfunc = dist_Real;
+                       break;
        }
 
        xi = (int)(floor(x));
@@ -1261,7 +1227,7 @@ void voronoi(float x, float y, float z, float *da, float *pa, float me, int dtyp
        for (xx = xi - 1; xx <= xi + 1; xx++) {
                for (yy = yi - 1; yy <= yi + 1; yy++) {
                        for (zz = zi - 1; zz <= zi + 1; zz++) {
-                               p = HASHPNT(xx, yy, zz);
+                               const float *p = HASHPNT(xx, yy, zz);
                                xd = x - (p[0] + xx);
                                yd = y - (p[1] + yy);
                                zd = z - (p[2] + zz);
@@ -1395,6 +1361,11 @@ static float voronoi_CrS(float x, float y, float z)
 /* returns unsigned cellnoise */
 static float cellNoiseU(float x, float y, float z)
 {
+       /* avoid precision issues on unit coordinates */
+       x = (x + 0.000001f) * 1.00001f;
+       y = (y + 0.000001f) * 1.00001f;
+       z = (z + 0.000001f) * 1.00001f;
+
        int xi = (int)(floor(x));
        int yi = (int)(floor(y));
        int zi = (int)(floor(z));
@@ -1410,12 +1381,17 @@ float cellNoise(float x, float y, float z)
 }
 
 /* returns a vector/point/color in ca, using point hasharray directly */
-void cellNoiseV(float x, float y, float z, float *ca)
+void cellNoiseV(float x, float y, float z, float ca[3])
 {
+       /* avoid precision issues on unit coordinates */
+       x = (x + 0.000001f) * 1.00001f;
+       y = (y + 0.000001f) * 1.00001f;
+       z = (z + 0.000001f) * 1.00001f;
+
        int xi = (int)(floor(x));
        int yi = (int)(floor(y));
        int zi = (int)(floor(z));
-       float *p = HASHPNT(xi, yi, zi);
+       const float *p = HASHPNT(xi, yi, zi);
        ca[0] = p[0];
        ca[1] = p[1];
        ca[2] = p[2];
@@ -1467,6 +1443,7 @@ float BLI_gNoise(float noisesize, float x, float y, float z, int hard, int noise
                        x += 1;
                        y += 1;
                        z += 1;
+                       break;
                }
        }
 
@@ -1476,7 +1453,7 @@ float BLI_gNoise(float noisesize, float x, float y, float z, int hard, int noise
                y *= noisesize;
                z *= noisesize;
        }
-       
+
        if (hard) return fabsf(2.0f * noisefunc(x, y, z) - 1.0f);
        return noisefunc(x, y, z);
 }
@@ -1487,7 +1464,7 @@ float BLI_gTurbulence(float noisesize, float x, float y, float z, int oct, int h
        float (*noisefunc)(float, float, float);
        float sum, t, amp = 1, fscale = 1;
        int i;
-       
+
        switch (noisebasis) {
                case 1:
                        noisefunc = orgPerlinNoiseU;
@@ -1522,6 +1499,7 @@ float BLI_gTurbulence(float noisesize, float x, float y, float z, int oct, int h
                        x += 1;
                        y += 1;
                        z += 1;
+                       break;
        }
 
        if (noisesize != 0.0f) {
@@ -1537,7 +1515,7 @@ float BLI_gTurbulence(float noisesize, float x, float y, float z, int oct, int h
                if (hard) t = fabsf(2.0f * t - 1.0f);
                sum += t * amp;
        }
-       
+
        sum *= ((float)(1 << oct) / (float)((1 << (oct + 1)) - 1));
 
        return sum;
@@ -1547,7 +1525,7 @@ float BLI_gTurbulence(float noisesize, float x, float y, float z, int oct, int h
 
 /*
  * The following code is based on Ken Musgrave's explanations and sample
- * source code in the book "Texturing and Modelling: A procedural approach"
+ * source code in the book "Texturing and Modeling: A procedural approach"
  */
 
 /*
@@ -1596,9 +1574,10 @@ float mg_fBm(float x, float y, float z, float H, float lacunarity, float octaves
                default:
                {
                        noisefunc = orgBlenderNoiseS;
+                       break;
                }
        }
-       
+
        for (i = 0; i < (int)octaves; i++) {
                value += noisefunc(x, y, z) * pwr;
                pwr *= pwHL;
@@ -1667,6 +1646,7 @@ float mg_MultiFractal(float x, float y, float z, float H, float lacunarity, floa
                default:
                {
                        noisefunc = orgBlenderNoiseS;
+                       break;
                }
        }
 
@@ -1734,6 +1714,7 @@ float mg_HeteroTerrain(float x, float y, float z, float H, float lacunarity, flo
                default:
                {
                        noisefunc = orgBlenderNoiseS;
+                       break;
                }
        }
 
@@ -1808,6 +1789,7 @@ float mg_HybridMultiFractal(float x, float y, float z, float H, float lacunarity
                default:
                {
                        noisefunc = orgBlenderNoiseS;
+                       break;
                }
        }
 
@@ -1850,7 +1832,7 @@ float mg_RidgedMultiFractal(float x, float y, float z, float H, float lacunarity
        int i;
        float pwHL = powf(lacunarity, -H);
        float pwr = pwHL;   /* starts with i=1 instead of 0 */
-       
+
        float (*noisefunc)(float, float, float);
        switch (noisebasis) {
                case 1:
@@ -1884,6 +1866,7 @@ float mg_RidgedMultiFractal(float x, float y, float z, float H, float lacunarity
                default:
                {
                        noisefunc = orgBlenderNoiseS;
+                       break;
                }
        }
 
@@ -1950,6 +1933,7 @@ float mg_VLNoise(float x, float y, float z, float distortion, int nbas1, int nba
                default:
                {
                        noisefunc1 = orgBlenderNoiseS;
+                       break;
                }
        }
 
@@ -1985,6 +1969,7 @@ float mg_VLNoise(float x, float y, float z, float distortion, int nbas1, int nba
                default:
                {
                        noisefunc2 = orgBlenderNoiseS;
+                       break;
                }
        }