""" // // /* * This implementation is "Improved Noise" as presented by * Ken Perlin at Siggraph 2002. The 3D function is a direct port * of his Java reference code which was once publicly available * on www.noisemachine.com (although I cleaned it up, made it * faster and made the code more readable), but the 1D, 2D and * 4D functions were implemented from scratch by me. * * This is a backport to C of my improved noise class in C++ * which was included in the Aqsis renderer project. * It is highly reusable without source code modifications. * */""" def FADE(t): return ( t * t * t * ( t * ( t * 6 - 15 ) + 10 ) ) def LERP(t, a, b): return ((a) + (t)*((b)-(a))) def FASTFLOOR(x): return (int(x)) if (int(x) < (x)) else (int(x) - 1) #define FADE(t) ( t * t * t * ( t * ( t * 6 - 15 ) + 10 ) ) #define FASTFLOOR(x) ( ((int)(x)<(x)) ? ((int)x) : ((int)x-1 ) ) #define LERP(t, a, b) ((a) + (t)*((b)-(a))) """/* * Permutation table. This is just a random jumble of all numbers 0-255, * repeated twice to avoid wrapping the index at 255 for each lookup. * This needs to be exactly the same for all instances on all platforms, * so it's easiest to just keep it as static explicit data. * This also removes the need for any initialisation of this class. * * Note that making this an int[] instead of a char[] might make the * code run faster on platforms with a high penalty for unaligned single * byte addressing. Intel x86 is generally single-byte-friendly, but * some other CPUs are faster with 4-aligned reads. * However, a char[] is smaller, which avoids cache trashing, and that * is probably the most important aspect on most architectures. * This array is accessed a *lot* by the noise functions. * A vector-valued noise over 3D accesses it 96 times, and a * float-valued 4D noise 64 times. We want this to fit in the cache! */""" perm = [151,160,137,91,90,15, 131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23, 190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33, 88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166, 77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244, 102,143,54, 65,25,63,161, 1,216,80,73,209,76,132,187,208, 89,18,169,200,196, 135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,123, 5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42, 223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167, 43,172,9, 129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,97,228, 251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,107, 49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254, 138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180, 151,160,137,91,90,15, 131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23, 190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33, 88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166, 77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244, 102,143,54, 65,25,63,161, 1,216,80,73,209,76,132,187,208, 89,18,169,200,196, 135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,123, 5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42, 223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167, 43,172,9, 129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,97,228, 251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,107, 49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254, 138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180 ] """* * Helper functions to compute gradients-dot-residualvectors (1D to 4D) * Note that these generate gradients of more than unit length. To make * a close match with the value range of classic Perlin noise, the final * noise values need to be rescaled. To match the RenderMan noise in a * statistical sense, the approximate scaling values (empirically * determined from test renderings) are: * 1D noise needs rescaling with 0.188 * 2D noise needs rescaling with 0.507 * 3D noise needs rescaling with 0.936 * 4D noise needs rescaling with 0.87 * Note that these noise functions are the most practical and useful * signed version of Perlin noise. To return values according to the * RenderMan specification from the SL noise() and pnoise() functions, * the noise values need to be scaled and offset to [0,1], like this: * float SLnoise = (noise3(x,y,z) + 1.0) * 0.5 *""" def grad1(hash: int, x: float): h = hash & 15 grad = 1.0 + (h & 7) if h & 8 > 0: grad = -grad return grad * x def grad2( hash: int, x: float, y: float ): h = hash & 7 u = x if h<4 else y v = y if h<4 else x return (-u if h & 1 > 0 else u) + (-2.0*v if (h&2) else 2.0*v) def grad3( hash: int, x: float, y: float , z: float ): h = hash & 15 u = x if h<8 else y v = y if h<4 else (x if (h==12 or h==14) else z) return (-u if (h&1 > 0) else u) + (-v if (h&2 > 0) else v) def grad4( hash, x, y, z, t ): h = hash & 31 u = x if h<24 else y v = y if h<16 else z w = z if h<8 else t return (-u if (h&1 > 0) else u) + (-v if (h&2>0) else v) + (-w if (h&4>0) else w) def noise1( x ): ix0 = FASTFLOOR( x ) fx0 = x - ix0 fx1 = fx0 - 1.0 ix1 = ( ix0+1 ) & 0xff ix0 = ix0 & 0xff s = FADE( fx0 ) n0 = grad1( perm[ ix0 ], fx0 ) n1 = grad1( perm[ ix1 ], fx1 ) return 0.188 * ( LERP( s, n0, n1 ) ) def pnoise1( x, px ): ix0 = FASTFLOOR( x ) fx0 = x - ix0 fx1 = fx0 - 1.0 ix1 = (( ix0 + 1 ) % px) & 0xff ix0 = ( ix0 % px ) & 0xff s = FADE( fx0 ) n0 = grad1( perm[ ix0 ], fx0 ) n1 = grad1( perm[ ix1 ], fx1 ) return 0.188 * ( LERP( s, n0, n1 ) ) def noise2( x, y ): ix0 = FASTFLOOR( x ) iy0 = FASTFLOOR( y ) fx0 = x - ix0 fy0 = y - iy0 fx1 = fx0 - 1.0 fy1 = fy0 - 1.0 ix1 = (ix0 + 1) & 0xff iy1 = (iy0 + 1) & 0xff ix0 = ix0 & 0xff iy0 = iy0 & 0xff t = FADE( fy0 ) s = FADE( fx0 ) nx0 = grad2(perm[ix0 + perm[iy0]], fx0, fy0) nx1 = grad2(perm[ix0 + perm[iy1]], fx0, fy1) n0 = LERP( t, nx0, nx1 ) nx0 = grad2(perm[ix1 + perm[iy0]], fx1, fy0) nx1 = grad2(perm[ix1 + perm[iy1]], fx1, fy1) n1 = LERP(t, nx0, nx1) return 0.507 * ( LERP( s, n0, n1 ) ) def pnoise2( x, y, px, py ): ix0 = FASTFLOOR( x ) iy0 = FASTFLOOR( y ) fx0 = x - ix0 fy0 = y - iy0 fx1 = fx0 - 1.0 fy1 = fy0 - 1.0 ix1 = (( ix0 + 1 ) % px) & 0xff iy1 = (( iy0 + 1 ) % py) & 0xff ix0 = ( ix0 % px ) & 0xff iy0 = ( iy0 % py ) & 0xff t = FADE( fy0 ) s = FADE( fx0 ) nx0 = grad2(perm[ix0 + perm[iy0]], fx0, fy0) nx1 = grad2(perm[ix0 + perm[iy1]], fx0, fy1) n0 = LERP( t, nx0, nx1 ) nx0 = grad2(perm[ix1 + perm[iy0]], fx1, fy0) nx1 = grad2(perm[ix1 + perm[iy1]], fx1, fy1) n1 = LERP(t, nx0, nx1) return 0.507 * ( LERP( s, n0, n1 ) ) def noise3( x, y, z ): ix0 = FASTFLOOR( x ) iy0 = FASTFLOOR( y ) iz0 = FASTFLOOR( z ) fx0 = x - ix0 fy0 = y - iy0 fz0 = z - iz0 fx1 = fx0 - 1.0 fy1 = fy0 - 1.0 fz1 = fz0 - 1.0 ix1 = ( ix0 + 1 ) & 0xff iy1 = ( iy0 + 1 ) & 0xff iz1 = ( iz0 + 1 ) & 0xff ix0 = ix0 & 0xff iy0 = iy0 & 0xff iz0 = iz0 & 0xff r = FADE( fz0 ) t = FADE( fy0 ) s = FADE( fx0 ) nxy0 = grad3(perm[ix0 + perm[iy0 + perm[iz0]]], fx0, fy0, fz0) nxy1 = grad3(perm[ix0 + perm[iy0 + perm[iz1]]], fx0, fy0, fz1) nx0 = LERP( r, nxy0, nxy1 ) nxy0 = grad3(perm[ix0 + perm[iy1 + perm[iz0]]], fx0, fy1, fz0) nxy1 = grad3(perm[ix0 + perm[iy1 + perm[iz1]]], fx0, fy1, fz1) nx1 = LERP( r, nxy0, nxy1 ) n0 = LERP( t, nx0, nx1 ) nxy0 = grad3(perm[ix1 + perm[iy0 + perm[iz0]]], fx1, fy0, fz0) nxy1 = grad3(perm[ix1 + perm[iy0 + perm[iz1]]], fx1, fy0, fz1) nx0 = LERP( r, nxy0, nxy1 ) nxy0 = grad3(perm[ix1 + perm[iy1 + perm[iz0]]], fx1, fy1, fz0) nxy1 = grad3(perm[ix1 + perm[iy1 + perm[iz1]]], fx1, fy1, fz1) nx1 = LERP( r, nxy0, nxy1 ) n1 = LERP( t, nx0, nx1 ) return 0.936 * ( LERP( s, n0, n1 ) ) def pnoise3( x, y, z, px, py, pz ): ix0 = FASTFLOOR( x ) iy0 = FASTFLOOR( y ) iz0 = FASTFLOOR( z ) fx0 = x - ix0 fy0 = y - iy0 fz0 = z - iz0 fx1 = fx0 - 1.0 fy1 = fy0 - 1.0 fz1 = fz0 - 1.0 ix1 = (( ix0 + 1 ) % px ) & 0xff iy1 = (( iy0 + 1 ) % py ) & 0xff iz1 = (( iz0 + 1 ) % pz ) & 0xff ix0 = ( ix0 % px ) & 0xff iy0 = ( iy0 % py ) & 0xff iz0 = ( iz0 % pz ) & 0xff r = FADE( fz0 ) t = FADE( fy0 ) s = FADE( fx0 ) nxy0 = grad3(perm[ix0 + perm[iy0 + perm[iz0]]], fx0, fy0, fz0) nxy1 = grad3(perm[ix0 + perm[iy0 + perm[iz1]]], fx0, fy0, fz1) nx0 = LERP( r, nxy0, nxy1 ) nxy0 = grad3(perm[ix0 + perm[iy1 + perm[iz0]]], fx0, fy1, fz0) nxy1 = grad3(perm[ix0 + perm[iy1 + perm[iz1]]], fx0, fy1, fz1) nx1 = LERP( r, nxy0, nxy1 ) n0 = LERP( t, nx0, nx1 ) nxy0 = grad3(perm[ix1 + perm[iy0 + perm[iz0]]], fx1, fy0, fz0) nxy1 = grad3(perm[ix1 + perm[iy0 + perm[iz1]]], fx1, fy0, fz1) nx0 = LERP( r, nxy0, nxy1 ) nxy0 = grad3(perm[ix1 + perm[iy1 + perm[iz0]]], fx1, fy1, fz0) nxy1 = grad3(perm[ix1 + perm[iy1 + perm[iz1]]], fx1, fy1, fz1) nx1 = LERP( r, nxy0, nxy1 ) n1 = LERP( t, nx0, nx1 ) return 0.936 * ( LERP( s, n0, n1 ) ) def noise4( x, y, z, w ): ix0 = FASTFLOOR( x ) iy0 = FASTFLOOR( y ) iz0 = FASTFLOOR( z ) iw0 = FASTFLOOR( w ) fx0 = x - ix0 fy0 = y - iy0 fz0 = z - iz0 fw0 = w - iw0 fx1 = fx0 - 1.0 fy1 = fy0 - 1.0 fz1 = fz0 - 1.0 fw1 = fw0 - 1.0 ix1 = ( ix0 + 1 ) & 0xff iy1 = ( iy0 + 1 ) & 0xff iz1 = ( iz0 + 1 ) & 0xff iw1 = ( iw0 + 1 ) & 0xff ix0 = ix0 & 0xff iy0 = iy0 & 0xff iz0 = iz0 & 0xff iw0 = iw0 & 0xff q = FADE( fw0 ) r = FADE( fz0 ) t = FADE( fy0 ) s = FADE( fx0 ) nxyz0 = grad4(perm[ix0 + perm[iy0 + perm[iz0 + perm[iw0]]]], fx0, fy0, fz0, fw0) nxyz1 = grad4(perm[ix0 + perm[iy0 + perm[iz0 + perm[iw1]]]], fx0, fy0, fz0, fw1) nxy0 = LERP( q, nxyz0, nxyz1 ) nxyz0 = grad4(perm[ix0 + perm[iy0 + perm[iz1 + perm[iw0]]]], fx0, fy0, fz1, fw0) nxyz1 = grad4(perm[ix0 + perm[iy0 + perm[iz1 + perm[iw1]]]], fx0, fy0, fz1, fw1) nxy1 = LERP( q, nxyz0, nxyz1 ) nx0 = LERP ( r, nxy0, nxy1 ) nxyz0 = grad4(perm[ix0 + perm[iy1 + perm[iz0 + perm[iw0]]]], fx0, fy1, fz0, fw0) nxyz1 = grad4(perm[ix0 + perm[iy1 + perm[iz0 + perm[iw1]]]], fx0, fy1, fz0, fw1) nxy0 = LERP( q, nxyz0, nxyz1 ) nxyz0 = grad4(perm[ix0 + perm[iy1 + perm[iz1 + perm[iw0]]]], fx0, fy1, fz1, fw0) nxyz1 = grad4(perm[ix0 + perm[iy1 + perm[iz1 + perm[iw1]]]], fx0, fy1, fz1, fw1) nxy1 = LERP( q, nxyz0, nxyz1 ) nx1 = LERP ( r, nxy0, nxy1 ) n0 = LERP( t, nx0, nx1 ) nxyz0 = grad4(perm[ix1 + perm[iy0 + perm[iz0 + perm[iw0]]]], fx1, fy0, fz0, fw0) nxyz1 = grad4(perm[ix1 + perm[iy0 + perm[iz0 + perm[iw1]]]], fx1, fy0, fz0, fw1) nxy0 = LERP( q, nxyz0, nxyz1 ) nxyz0 = grad4(perm[ix1 + perm[iy0 + perm[iz1 + perm[iw0]]]], fx1, fy0, fz1, fw0) nxyz1 = grad4(perm[ix1 + perm[iy0 + perm[iz1 + perm[iw1]]]], fx1, fy0, fz1, fw1) nxy1 = LERP( q, nxyz0, nxyz1 ) nx0 = LERP ( r, nxy0, nxy1 ) nxyz0 = grad4(perm[ix1 + perm[iy1 + perm[iz0 + perm[iw0]]]], fx1, fy1, fz0, fw0) nxyz1 = grad4(perm[ix1 + perm[iy1 + perm[iz0 + perm[iw1]]]], fx1, fy1, fz0, fw1) nxy0 = LERP( q, nxyz0, nxyz1 ) nxyz0 = grad4(perm[ix1 + perm[iy1 + perm[iz1 + perm[iw0]]]], fx1, fy1, fz1, fw0) nxyz1 = grad4(perm[ix1 + perm[iy1 + perm[iz1 + perm[iw1]]]], fx1, fy1, fz1, fw1) nxy1 = LERP( q, nxyz0, nxyz1 ) nx1 = LERP ( r, nxy0, nxy1 ) n1 = LERP( t, nx0, nx1 ) return 0.87 * ( LERP( s, n0, n1 ) ) def pnoise4( x, y, z, w, px, py, pz, pw ): ix0 = FASTFLOOR( x ) iy0 = FASTFLOOR( y ) iz0 = FASTFLOOR( z ) iw0 = FASTFLOOR( w ) fx0 = x - ix0 fy0 = y - iy0 fz0 = z - iz0 fw0 = w - iw0 fx1 = fx0 - 1.0 fy1 = fy0 - 1.0 fz1 = fz0 - 1.0 fw1 = fw0 - 1.0 ix1 = (( ix0 + 1 ) % px ) & 0xff iy1 = (( iy0 + 1 ) % py ) & 0xff iz1 = (( iz0 + 1 ) % pz ) & 0xff iw1 = (( iw0 + 1 ) % pw ) & 0xff ix0 = ( ix0 % px ) & 0xff iy0 = ( iy0 % py ) & 0xff iz0 = ( iz0 % pz ) & 0xff iw0 = ( iw0 % pw ) & 0xff q = FADE( fw0 ) r = FADE( fz0 ) t = FADE( fy0 ) s = FADE( fx0 ) nxyz0 = grad4(perm[ix0 + perm[iy0 + perm[iz0 + perm[iw0]]]], fx0, fy0, fz0, fw0) nxyz1 = grad4(perm[ix0 + perm[iy0 + perm[iz0 + perm[iw1]]]], fx0, fy0, fz0, fw1) nxy0 = LERP( q, nxyz0, nxyz1 ) nxyz0 = grad4(perm[ix0 + perm[iy0 + perm[iz1 + perm[iw0]]]], fx0, fy0, fz1, fw0) nxyz1 = grad4(perm[ix0 + perm[iy0 + perm[iz1 + perm[iw1]]]], fx0, fy0, fz1, fw1) nxy1 = LERP( q, nxyz0, nxyz1 ) nx0 = LERP ( r, nxy0, nxy1 ) nxyz0 = grad4(perm[ix0 + perm[iy1 + perm[iz0 + perm[iw0]]]], fx0, fy1, fz0, fw0) nxyz1 = grad4(perm[ix0 + perm[iy1 + perm[iz0 + perm[iw1]]]], fx0, fy1, fz0, fw1) nxy0 = LERP( q, nxyz0, nxyz1 ) nxyz0 = grad4(perm[ix0 + perm[iy1 + perm[iz1 + perm[iw0]]]], fx0, fy1, fz1, fw0) nxyz1 = grad4(perm[ix0 + perm[iy1 + perm[iz1 + perm[iw1]]]], fx0, fy1, fz1, fw1) nxy1 = LERP( q, nxyz0, nxyz1 ) nx1 = LERP ( r, nxy0, nxy1 ) n0 = LERP( t, nx0, nx1 ) nxyz0 = grad4(perm[ix1 + perm[iy0 + perm[iz0 + perm[iw0]]]], fx1, fy0, fz0, fw0) nxyz1 = grad4(perm[ix1 + perm[iy0 + perm[iz0 + perm[iw1]]]], fx1, fy0, fz0, fw1) nxy0 = LERP( q, nxyz0, nxyz1 ) nxyz0 = grad4(perm[ix1 + perm[iy0 + perm[iz1 + perm[iw0]]]], fx1, fy0, fz1, fw0) nxyz1 = grad4(perm[ix1 + perm[iy0 + perm[iz1 + perm[iw1]]]], fx1, fy0, fz1, fw1) nxy1 = LERP( q, nxyz0, nxyz1 ) nx0 = LERP ( r, nxy0, nxy1 ) nxyz0 = grad4(perm[ix1 + perm[iy1 + perm[iz0 + perm[iw0]]]], fx1, fy1, fz0, fw0) nxyz1 = grad4(perm[ix1 + perm[iy1 + perm[iz0 + perm[iw1]]]], fx1, fy1, fz0, fw1) nxy0 = LERP( q, nxyz0, nxyz1 ) nxyz0 = grad4(perm[ix1 + perm[iy1 + perm[iz1 + perm[iw0]]]], fx1, fy1, fz1, fw0) nxyz1 = grad4(perm[ix1 + perm[iy1 + perm[iz1 + perm[iw1]]]], fx1, fy1, fz1, fw1) nxy1 = LERP( q, nxyz0, nxyz1 ) nx1 = LERP ( r, nxy0, nxy1 ) n1 = LERP( t, nx0, nx1 ) return 0.87 * ( LERP( s, n0, n1 ) )