Cleanup: Remove more #if 0 blocks
[blender.git] / source / blender / blenlib / intern / noise.c
index 792bf929182c92977a71e7e19163d72d332e01ca..8ee99544ca58484fbef53b5adb00c4a56d90a00c 100644 (file)
  *  \ingroup bli
  */
 
  *  \ingroup bli
  */
 
-
-#ifdef _WIN32   
-#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]);
 #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 */
 //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]
 
 /* 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,
        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
 };
 
        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,
        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,
        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,
@@ -281,11 +275,11 @@ static float npfade(float t)
        return (t * t * t * (t * (t * 6.0f - 15.0f) + 10.0f));
 }
 
        return (t * t * t * (t * (t * 6.0f - 15.0f) + 10.0f));
 }
 
-static float grad(int hash, float x, float y, float z)
+static float grad(int hash_val, float x, float y, float z)
 {
 {
-       int h = hash & 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;
+       int h = hash_val & 15;                 /* CONVERT LO 4 BITS OF HASH CODE */
+       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);
 }
 
        return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
 }
 
@@ -301,8 +295,8 @@ static float newPerlin(float x, float y, float z)
        u = npfade(x);      /* COMPUTE FADE CURVES */
        v = npfade(y);      /* FOR EACH OF X,Y,Z. */
        w = npfade(z);
        u = npfade(x);      /* COMPUTE FADE CURVES */
        v = npfade(y);      /* FOR EACH OF X,Y,Z. */
        w = npfade(z);
-       A = hash[X  ]+Y;  AA = hash[A]+Z;  AB = hash[A+1]+Z;      /* HASH COORDINATES OF */
-       B = hash[X+1]+Y;  BA = hash[B]+Z;  BB = hash[B+1]+Z;      /* THE 8 CUBE CORNERS, */
+       A = hash[X    ] + Y;  AA = hash[A] + Z;  AB = hash[A + 1] + Z;      /* HASH COORDINATES OF */
+       B = hash[X + 1] + Y;  BA = hash[B] + Z;  BB = hash[B + 1] + Z;      /* THE 8 CUBE CORNERS, */
        return lerp(w, lerp(v, lerp(u, grad(hash[AA   ],  x,     y,     z    ),   /* AND ADD */
                                       grad(hash[BA   ],  x - 1, y,     z    )),  /* BLENDED */
                               lerp(u, grad(hash[AB   ],  x,     y - 1, z    ),   /* RESULTS */
        return lerp(w, lerp(v, lerp(u, grad(hash[AA   ],  x,     y,     z    ),   /* AND ADD */
                                       grad(hash[BA   ],  x - 1, y,     z    )),  /* BLENDED */
                               lerp(u, grad(hash[AB   ],  x,     y - 1, z    ),   /* RESULTS */
@@ -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)
 {
 /* 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;
        float fx, fy, fz, ox, oy, oz, jx, jy, jz;
        float n = 0.5;
        int ix, iy, iz, b00, b01, b10, b11, b20, b21;
@@ -398,7 +393,8 @@ static float orgBlenderNoise(float x, float y, float z)
        h = hashvectf + 3 * hash[b21 + b11];
        n += i * (h[0] * jx + h[1] * jy + h[2] * jz);
 
        h = hashvectf + 3 * hash[b21 + b11];
        n += i * (h[0] * jx + h[1] * jy + h[2] * jz);
 
-       if (n < 0.0f) n = 0.0f; else if (n > 1.0f) n = 1.0f;
+       if      (n < 0.0f) n = 0.0f;
+       else if (n > 1.0f) n = 1.0f;
        return n;
 }
 
        return n;
 }
 
@@ -425,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);
        float s, d = 0.5, div = 1.0;
 
        s = BLI_hnoise(noisesize, x, y, z);
-       
+
        while (nr > 0) {
        while (nr > 0) {
-       
+
                s += d * BLI_hnoise(noisesize * d, x, y, z);
                div += d;
                d *= 0.5f;
                s += d * BLI_hnoise(noisesize * d, x, y, z);
                div += d;
                d *= 0.5f;
@@ -442,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)));
        float s, d = 0.5, div = 1.0;
 
        s = fabsf((-1.0f + 2.0f * BLI_hnoise(noisesize, x, y, z)));
-       
+
        while (nr > 0) {
        while (nr > 0) {
-       
+
                s += fabsf(d * (-1.0f + 2.0f * BLI_hnoise(noisesize * d, x, y, z)));
                div += d;
                d *= 0.5f;
                s += fabsf(d * (-1.0f + 2.0f * BLI_hnoise(noisesize * d, x, y, z)));
                div += d;
                d *= 0.5f;
-               
+
                nr--;
        }
        return s / div;
                nr--;
        }
        return s / div;
@@ -456,20 +452,54 @@ float BLI_turbulence1(float noisesize, float x, float y, float z, int nr)
 
 /* ********************* FROM PERLIN HIMSELF: ******************** */
 
 
 /* ********************* FROM PERLIN HIMSELF: ******************** */
 
-static char p[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, 0x8B, 0x63, 0x89, 0x2F, 0xB8, 0xB4, 0x97, 0x83, 0xF2, 0x8F, 0x18, 0xC7, 0x51, 0x14, 0x65, 0x87, 0x48, 0x20, 0x42, 0xA8, 0x80, 0xB5, 0x40, 0x13, 0xB2, 0x22, 0x7E, 0x57,
-       0xBC, 0x7F, 0x6B, 0x9D, 0x86, 0x4C, 0xC8, 0xDB, 0x7C, 0xD5, 0x25, 0x4E, 0x5A, 0x55, 0x74, 0x50, 0xCD, 0xB3, 0x7A, 0xBB, 0xC3, 0xCB, 0xB6, 0xE2, 0xE4, 0xEC, 0xFD, 0x98, 0xB, 0x96, 0xD3, 0x9E, 0x5C, 0xA1, 0x64, 0xF1, 0x81, 0x61, 0xE1, 0xC4, 0x24, 0x72, 0x49, 0x8C, 0x90, 0x4B, 0x84, 0x34, 0x38, 0xAB, 0x78, 0xCA, 0x1F, 0x1, 0xD7, 0x93, 0x11, 0xC1, 0x58, 0xA9, 0x31, 0xF9, 0x44, 0x6D,
-       0xBF, 0x33, 0x9C, 0x5F, 0x9, 0x94, 0xA3, 0x85, 0x6, 0xC6, 0x9A, 0x1E, 0x7B, 0x46, 0x15, 0x30, 0x27, 0x2B, 0x1B, 0x71, 0x3C, 0x5B, 0xD6, 0x6F, 0x62, 0xAC, 0x4F, 0xC2, 0xC0, 0xE, 0xB1, 0x23, 0xA7, 0xDF, 0x47, 0xB0, 0x77, 0x69, 0x5, 0xE9, 0xE6, 0xE7, 0x76, 0x73, 0xF, 0xFE, 0x6E, 0x9B, 0x56, 0xEF, 0x12, 0xA5, 0x37, 0xFC, 0xAE, 0xD9, 0x3, 0x8E, 0xDD, 0x10, 0xB9, 0xCE, 0xC9, 0x8D,
-       0xDA, 0x2A, 0xBD, 0x68, 0x17, 0x9F, 0xBE, 0xD4, 0xA, 0xCC, 0xD2, 0xE8, 0x43, 0x3D, 0x70, 0xB7, 0x2, 0x7D, 0x99, 0xD8, 0xD, 0x60, 0x8A, 0x4, 0x2C, 0x3E, 0x92, 0xE5, 0xAF, 0x53, 0x7, 0xE0, 0x29, 0xA6, 0xC5, 0xE3, 0xF5, 0xF7, 0x4A, 0x41, 0x26, 0x6A, 0x16, 0x5E, 0x52, 0x2D, 0x21, 0xAD, 0xF0, 0x91, 0xFF, 0xEA, 0x54, 0xFA, 0x66, 0x1A, 0x45, 0x39, 0xCF, 0x75, 0xA4, 0x88, 0xFB, 0x5D,
-       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, 0xB5, 0x40, 0x13, 0xB2, 0x22, 0x7E, 0x57,
-       0xBC, 0x7F, 0x6B, 0x9D, 0x86, 0x4C, 0xC8, 0xDB, 0x7C, 0xD5, 0x25, 0x4E, 0x5A, 0x55, 0x74, 0x50, 0xCD, 0xB3, 0x7A, 0xBB, 0xC3, 0xCB, 0xB6, 0xE2, 0xE4, 0xEC, 0xFD, 0x98, 0xB, 0x96, 0xD3, 0x9E, 0x5C, 0xA1, 0x64, 0xF1, 0x81, 0x61, 0xE1, 0xC4, 0x24, 0x72, 0x49, 0x8C, 0x90, 0x4B, 0x84, 0x34, 0x38, 0xAB, 0x78, 0xCA, 0x1F, 0x1, 0xD7, 0x93, 0x11, 0xC1, 0x58, 0xA9, 0x31, 0xF9, 0x44, 0x6D,
-       0xBF, 0x33, 0x9C, 0x5F, 0x9, 0x94, 0xA3, 0x85, 0x6, 0xC6, 0x9A, 0x1E, 0x7B, 0x46, 0x15, 0x30, 0x27, 0x2B, 0x1B, 0x71, 0x3C, 0x5B, 0xD6, 0x6F, 0x62, 0xAC, 0x4F, 0xC2, 0xC0, 0xE, 0xB1, 0x23, 0xA7, 0xDF, 0x47, 0xB0, 0x77, 0x69, 0x5, 0xE9, 0xE6, 0xE7, 0x76, 0x73, 0xF, 0xFE, 0x6E, 0x9B, 0x56, 0xEF, 0x12, 0xA5, 0x37, 0xFC, 0xAE, 0xD9, 0x3, 0x8E, 0xDD, 0x10, 0xB9, 0xCE, 0xC9, 0x8D,
-       0xDA, 0x2A, 0xBD, 0x68, 0x17, 0x9F, 0xBE, 0xD4, 0xA, 0xCC, 0xD2, 0xE8, 0x43, 0x3D, 0x70, 0xB7, 0x2, 0x7D, 0x99, 0xD8, 0xD, 0x60, 0x8A, 0x4, 0x2C, 0x3E, 0x92, 0xE5, 0xAF, 0x53, 0x7, 0xE0, 0x29, 0xA6, 0xC5, 0xE3, 0xF5, 0xF7, 0x4A, 0x41, 0x26, 0x6A, 0x16, 0x5E, 0x52, 0x2D, 0x21, 0xAD, 0xF0, 0x91, 0xFF, 0xEA, 0x54, 0xFA, 0x66, 0x1A, 0x45, 0x39, 0xCF, 0x75, 0xA4, 0x88, 0xFB, 0x5D,
-       0xA2, 0xA0
+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,
+       0x8B, 0x63, 0x89, 0x2F, 0xB8, 0xB4, 0x97, 0x83, 0xF2, 0x8F, 0x18, 0xC7,
+       0x51, 0x14, 0x65, 0x87, 0x48, 0x20, 0x42, 0xA8, 0x80, 0xB5, 0x40, 0x13,
+       0xB2, 0x22, 0x7E, 0x57, 0xBC, 0x7F, 0x6B, 0x9D, 0x86, 0x4C, 0xC8, 0xDB,
+       0x7C, 0xD5, 0x25, 0x4E, 0x5A, 0x55, 0x74, 0x50, 0xCD, 0xB3, 0x7A, 0xBB,
+       0xC3, 0xCB, 0xB6, 0xE2, 0xE4, 0xEC, 0xFD, 0x98, 0xB,  0x96, 0xD3, 0x9E,
+       0x5C, 0xA1, 0x64, 0xF1, 0x81, 0x61, 0xE1, 0xC4, 0x24, 0x72, 0x49, 0x8C,
+       0x90, 0x4B, 0x84, 0x34, 0x38, 0xAB, 0x78, 0xCA, 0x1F, 0x1,  0xD7, 0x93,
+       0x11, 0xC1, 0x58, 0xA9, 0x31, 0xF9, 0x44, 0x6D, 0xBF, 0x33, 0x9C, 0x5F,
+       0x9,  0x94, 0xA3, 0x85, 0x6,  0xC6, 0x9A, 0x1E, 0x7B, 0x46, 0x15, 0x30,
+       0x27, 0x2B, 0x1B, 0x71, 0x3C, 0x5B, 0xD6, 0x6F, 0x62, 0xAC, 0x4F, 0xC2,
+       0xC0, 0xE,  0xB1, 0x23, 0xA7, 0xDF, 0x47, 0xB0, 0x77, 0x69, 0x5,  0xE9,
+       0xE6, 0xE7, 0x76, 0x73, 0xF,  0xFE, 0x6E, 0x9B, 0x56, 0xEF, 0x12, 0xA5,
+       0x37, 0xFC, 0xAE, 0xD9, 0x3,  0x8E, 0xDD, 0x10, 0xB9, 0xCE, 0xC9, 0x8D,
+       0xDA, 0x2A, 0xBD, 0x68, 0x17, 0x9F, 0xBE, 0xD4, 0xA,  0xCC, 0xD2, 0xE8,
+       0x43, 0x3D, 0x70, 0xB7, 0x2,  0x7D, 0x99, 0xD8, 0xD,  0x60, 0x8A, 0x4,
+       0x2C, 0x3E, 0x92, 0xE5, 0xAF, 0x53, 0x7,  0xE0, 0x29, 0xA6, 0xC5, 0xE3,
+       0xF5, 0xF7, 0x4A, 0x41, 0x26, 0x6A, 0x16, 0x5E, 0x52, 0x2D, 0x21, 0xAD,
+       0xF0, 0x91, 0xFF, 0xEA, 0x54, 0xFA, 0x66, 0x1A, 0x45, 0x39, 0xCF, 0x75,
+       0xA4, 0x88, 0xFB, 0x5D, 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, 0xB5, 0x40, 0x13, 0xB2, 0x22, 0x7E, 0x57, 0xBC, 0x7F, 0x6B, 0x9D,
+       0x86, 0x4C, 0xC8, 0xDB, 0x7C, 0xD5, 0x25, 0x4E, 0x5A, 0x55, 0x74, 0x50,
+       0xCD, 0xB3, 0x7A, 0xBB, 0xC3, 0xCB, 0xB6, 0xE2, 0xE4, 0xEC, 0xFD, 0x98,
+       0xB,  0x96, 0xD3, 0x9E, 0x5C, 0xA1, 0x64, 0xF1, 0x81, 0x61, 0xE1, 0xC4,
+       0x24, 0x72, 0x49, 0x8C, 0x90, 0x4B, 0x84, 0x34, 0x38, 0xAB, 0x78, 0xCA,
+       0x1F, 0x1,  0xD7, 0x93, 0x11, 0xC1, 0x58, 0xA9, 0x31, 0xF9, 0x44, 0x6D,
+       0xBF, 0x33, 0x9C, 0x5F, 0x9,  0x94, 0xA3, 0x85, 0x6,  0xC6, 0x9A, 0x1E,
+       0x7B, 0x46, 0x15, 0x30, 0x27, 0x2B, 0x1B, 0x71, 0x3C, 0x5B, 0xD6, 0x6F,
+       0x62, 0xAC, 0x4F, 0xC2, 0xC0, 0xE,  0xB1, 0x23, 0xA7, 0xDF, 0x47, 0xB0,
+       0x77, 0x69, 0x5,  0xE9, 0xE6, 0xE7, 0x76, 0x73, 0xF,  0xFE, 0x6E, 0x9B,
+       0x56, 0xEF, 0x12, 0xA5, 0x37, 0xFC, 0xAE, 0xD9, 0x3,  0x8E, 0xDD, 0x10,
+       0xB9, 0xCE, 0xC9, 0x8D, 0xDA, 0x2A, 0xBD, 0x68, 0x17, 0x9F, 0xBE, 0xD4,
+       0xA,  0xCC, 0xD2, 0xE8, 0x43, 0x3D, 0x70, 0xB7, 0x2,  0x7D, 0x99, 0xD8,
+       0xD,  0x60, 0x8A, 0x4,  0x2C, 0x3E, 0x92, 0xE5, 0xAF, 0x53, 0x7,  0xE0,
+       0x29, 0xA6, 0xC5, 0xE3, 0xF5, 0xF7, 0x4A, 0x41, 0x26, 0x6A, 0x16, 0x5E,
+       0x52, 0x2D, 0x21, 0xAD, 0xF0, 0x91, 0xFF, 0xEA, 0x54, 0xFA, 0x66, 0x1A,
+       0x45, 0x39, 0xCF, 0x75, 0xA4, 0x88, 0xFB, 0x5D, 0xA2, 0xA0
 };
 
 
 };
 
 
-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},
        {0.33783, 0.715698, -0.611206},
        {-0.944031, -0.326599, -0.045624},
        {-0.101074, -0.416443, -0.903503},
@@ -998,8 +1028,11 @@ static float g[512 + 2][3] = {
 
 static float noise3_perlin(float vec[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;
        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;
 
 
        register int i, j;
 
 
@@ -1015,8 +1048,8 @@ static float noise3_perlin(float vec[3])
        b01 = p[i + by1];
        b11 = p[j + by1];
 
        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 */
 
 
 /* lerp moved to improved perlin above */
 
@@ -1059,26 +1092,6 @@ static float noise3_perlin(float vec[3])
 #undef SURVE
 }
 
 #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)
 {
 /* for use with BLI_gNoise/gTurbulence, returns signed noise */
 static float orgPerlinNoise(float x, float y, float z)
 {
@@ -1114,19 +1127,6 @@ float BLI_hnoisep(float noisesize, float x, float y, float z)
        return noise3_perlin(vec);
 }
 
        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 */
 /******************/
 /******************/
 /* VORONOI/WORLEY */
 /******************/
@@ -1192,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;
 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) {
 
        float (*distfunc)(float, float, float, float);
        switch (dtype) {
@@ -1217,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;
                case 0:
                default:
                        distfunc = dist_Real;
+                       break;
        }
 
        xi = (int)(floor(x));
        }
 
        xi = (int)(floor(x));
@@ -1226,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++) {
        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);
                                xd = x - (p[0] + xx);
                                yd = y - (p[1] + yy);
                                zd = z - (p[2] + zz);
@@ -1360,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)
 {
 /* 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));
        int xi = (int)(floor(x));
        int yi = (int)(floor(y));
        int zi = (int)(floor(z));
@@ -1375,12 +1381,17 @@ float cellNoise(float x, float y, float z)
 }
 
 /* returns a vector/point/color in ca, using point hasharray directly */
 }
 
 /* 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));
        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];
        ca[0] = p[0];
        ca[1] = p[1];
        ca[2] = p[2];
@@ -1425,12 +1436,14 @@ float BLI_gNoise(float noisesize, float x, float y, float z, int hard, int noise
                        noisefunc = cellNoiseU;
                        break;
                case 0:
                        noisefunc = cellNoiseU;
                        break;
                case 0:
-               default: {
+               default:
+               {
                        noisefunc = orgBlenderNoise;
                        /* add one to make return value same as BLI_hnoise */
                        x += 1;
                        y += 1;
                        z += 1;
                        noisefunc = orgBlenderNoise;
                        /* add one to make return value same as BLI_hnoise */
                        x += 1;
                        y += 1;
                        z += 1;
+                       break;
                }
        }
 
                }
        }
 
@@ -1440,7 +1453,7 @@ float BLI_gNoise(float noisesize, float x, float y, float z, int hard, int noise
                y *= noisesize;
                z *= noisesize;
        }
                y *= noisesize;
                z *= noisesize;
        }
-       
+
        if (hard) return fabsf(2.0f * noisefunc(x, y, z) - 1.0f);
        return noisefunc(x, y, z);
 }
        if (hard) return fabsf(2.0f * noisefunc(x, y, z) - 1.0f);
        return noisefunc(x, y, z);
 }
@@ -1451,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;
        float (*noisefunc)(float, float, float);
        float sum, t, amp = 1, fscale = 1;
        int i;
-       
+
        switch (noisebasis) {
                case 1:
                        noisefunc = orgPerlinNoiseU;
        switch (noisebasis) {
                case 1:
                        noisefunc = orgPerlinNoiseU;
@@ -1486,6 +1499,7 @@ float BLI_gTurbulence(float noisesize, float x, float y, float z, int oct, int h
                        x += 1;
                        y += 1;
                        z += 1;
                        x += 1;
                        y += 1;
                        z += 1;
+                       break;
        }
 
        if (noisesize != 0.0f) {
        }
 
        if (noisesize != 0.0f) {
@@ -1501,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;
        }
                if (hard) t = fabsf(2.0f * t - 1.0f);
                sum += t * amp;
        }
-       
+
        sum *= ((float)(1 << oct) / (float)((1 << (oct + 1)) - 1));
 
        return sum;
        sum *= ((float)(1 << oct) / (float)((1 << (oct + 1)) - 1));
 
        return sum;
@@ -1511,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
 
 /*
  * 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"
  */
 
 /*
  */
 
 /*
@@ -1557,11 +1571,13 @@ float mg_fBm(float x, float y, float z, float H, float lacunarity, float octaves
                        noisefunc = cellNoise;
                        break;
                case 0:
                        noisefunc = cellNoise;
                        break;
                case 0:
-               default: {
+               default:
+               {
                        noisefunc = orgBlenderNoiseS;
                        noisefunc = orgBlenderNoiseS;
+                       break;
                }
        }
                }
        }
-       
+
        for (i = 0; i < (int)octaves; i++) {
                value += noisefunc(x, y, z) * pwr;
                pwr *= pwHL;
        for (i = 0; i < (int)octaves; i++) {
                value += noisefunc(x, y, z) * pwr;
                pwr *= pwHL;
@@ -1627,8 +1643,10 @@ float mg_MultiFractal(float x, float y, float z, float H, float lacunarity, floa
                        noisefunc = cellNoise;
                        break;
                case 0:
                        noisefunc = cellNoise;
                        break;
                case 0:
-               default: {
+               default:
+               {
                        noisefunc = orgBlenderNoiseS;
                        noisefunc = orgBlenderNoiseS;
+                       break;
                }
        }
 
                }
        }
 
@@ -1693,8 +1711,10 @@ float mg_HeteroTerrain(float x, float y, float z, float H, float lacunarity, flo
                        noisefunc = cellNoise;
                        break;
                case 0:
                        noisefunc = cellNoise;
                        break;
                case 0:
-               default: {
+               default:
+               {
                        noisefunc = orgBlenderNoiseS;
                        noisefunc = orgBlenderNoiseS;
+                       break;
                }
        }
 
                }
        }
 
@@ -1766,8 +1786,10 @@ float mg_HybridMultiFractal(float x, float y, float z, float H, float lacunarity
                        noisefunc = cellNoise;
                        break;
                case 0:
                        noisefunc = cellNoise;
                        break;
                case 0:
-               default: {
+               default:
+               {
                        noisefunc = orgBlenderNoiseS;
                        noisefunc = orgBlenderNoiseS;
+                       break;
                }
        }
 
                }
        }
 
@@ -1810,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 */
        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:
        float (*noisefunc)(float, float, float);
        switch (noisebasis) {
                case 1:
@@ -1841,8 +1863,10 @@ float mg_RidgedMultiFractal(float x, float y, float z, float H, float lacunarity
                        noisefunc = cellNoise;
                        break;
                case 0:
                        noisefunc = cellNoise;
                        break;
                case 0:
-               default: {
+               default:
+               {
                        noisefunc = orgBlenderNoiseS;
                        noisefunc = orgBlenderNoiseS;
+                       break;
                }
        }
 
                }
        }
 
@@ -1856,7 +1880,8 @@ float mg_RidgedMultiFractal(float x, float y, float z, float H, float lacunarity
                y *= lacunarity;
                z *= lacunarity;
                weight = signal * gain;
                y *= lacunarity;
                z *= lacunarity;
                weight = signal * gain;
-               if (weight > 1.0f) weight = 1.0f; else if (weight < 0.0f) weight = 0.0f;
+               if      (weight > 1.0f) weight = 1.0f;
+               else if (weight < 0.0f) weight = 0.0f;
                signal = offset - fabsf(noisefunc(x, y, z));
                signal *= signal;
                signal *= weight;
                signal = offset - fabsf(noisefunc(x, y, z));
                signal *= signal;
                signal *= weight;
@@ -1905,8 +1930,10 @@ float mg_VLNoise(float x, float y, float z, float distortion, int nbas1, int nba
                        noisefunc1 = cellNoise;
                        break;
                case 0:
                        noisefunc1 = cellNoise;
                        break;
                case 0:
-               default: {
+               default:
+               {
                        noisefunc1 = orgBlenderNoiseS;
                        noisefunc1 = orgBlenderNoiseS;
+                       break;
                }
        }
 
                }
        }
 
@@ -1939,8 +1966,10 @@ float mg_VLNoise(float x, float y, float z, float distortion, int nbas1, int nba
                        noisefunc2 = cellNoise;
                        break;
                case 0:
                        noisefunc2 = cellNoise;
                        break;
                case 0:
-               default: {
+               default:
+               {
                        noisefunc2 = orgBlenderNoiseS;
                        noisefunc2 = orgBlenderNoiseS;
+                       break;
                }
        }
 
                }
        }