Cleanup: Remove more #if 0 blocks
[blender.git] / source / blender / blenlib / intern / noise.c
index 5b9fefe..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"
@@ -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);
 }
 
@@ -427,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;
@@ -444,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;
@@ -458,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,
@@ -505,7 +499,7 @@ static const char p[512 + 2] = {
 };
 
 
-static const 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},
@@ -1034,6 +1028,8 @@ static const 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, sx, sy, sz, a, b, c, d, t, u, v;
        const float *q;
@@ -1052,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 */
 
@@ -1096,26 +1092,6 @@ static float noise3_perlin(float vec[3])
 #undef SURVE
 }
 
-#if 0
-static float turbulence_perlin(const float point[3], 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)
 {
@@ -1151,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 */
 /******************/
@@ -1398,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));
@@ -1413,8 +1381,13 @@ 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));
@@ -1480,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);
 }
@@ -1491,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;
@@ -1542,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;
@@ -1552,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"
  */
 
 /*
@@ -1604,7 +1577,7 @@ float mg_fBm(float x, float y, float z, float H, float lacunarity, float octaves
                        break;
                }
        }
-       
+
        for (i = 0; i < (int)octaves; i++) {
                value += noisefunc(x, y, z) * pwr;
                pwr *= pwHL;
@@ -1859,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: