|
|
@@ -0,0 +1,550 @@
|
|
|
+// noise1234
|
|
|
+//
|
|
|
+// Author: Stefan Gustavson, 2003-2005
|
|
|
+// Contact: [email protected]
|
|
|
+//
|
|
|
+// This code was GPL licensed until February 2011.
|
|
|
+// As the original author of this code, I hereby
|
|
|
+// release it into the public domain.
|
|
|
+// Please feel free to use it for whatever you want.
|
|
|
+// Credit is appreciated where appropriate, and I also
|
|
|
+// appreciate being told where this code finds any use,
|
|
|
+// but you may do as you like.
|
|
|
+
|
|
|
+//Ported to JavaScript by Mike mikechambers
|
|
|
+//http://www.mikechambers.com
|
|
|
+//
|
|
|
+// Note, all return values are scaled to be between 0 and 1
|
|
|
+//
|
|
|
+//From original C at:
|
|
|
+//https://github.com/stegu/perlin-noise
|
|
|
+//https://github.com/stegu/perlin-noise/blob/master/src/noise1234.c
|
|
|
+
|
|
|
+/*
|
|
|
+ * 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.
|
|
|
+ *
|
|
|
+ */
|
|
|
+
|
|
|
+// This is the new and improved, C(2) continuous interpolant
|
|
|
+function fade(t) {
|
|
|
+ return ( t * t * t * ( t * ( t * 6 - 15 ) + 10 ) );
|
|
|
+}
|
|
|
+
|
|
|
+function lerp(t, a, b) {
|
|
|
+ return ((a) + (t)*((b)-(a)));
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+//---------------------------------------------------------------------
|
|
|
+// Static data
|
|
|
+
|
|
|
+/*
|
|
|
+ * 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!
|
|
|
+ */
|
|
|
+const 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
|
|
|
+ */
|
|
|
+
|
|
|
+function grad1( hash, x ) {
|
|
|
+ let h = hash & 15;
|
|
|
+ let grad = 1.0 + (h & 7); // Gradient value 1.0, 2.0, ..., 8.0
|
|
|
+ if (h&8) grad = -grad; // and a random sign for the gradient
|
|
|
+ return ( grad * x ); // Multiply the gradient with the distance
|
|
|
+}
|
|
|
+
|
|
|
+function grad2( hash, x, y ) {
|
|
|
+ let h = hash & 7; // Convert low 3 bits of hash code
|
|
|
+ let u = h<4 ? x : y; // into 8 simple gradient directions,
|
|
|
+ let v = h<4 ? y : x; // and compute the dot product with (x,y).
|
|
|
+ return ((h&1)? -u : u) + ((h&2)? -2.0*v : 2.0*v);
|
|
|
+}
|
|
|
+
|
|
|
+function grad3( hash, x, y , z ) {
|
|
|
+ let h = hash & 15; // Convert low 4 bits of hash code into 12 simple
|
|
|
+ let u = h<8 ? x : y; // gradient directions, and compute dot product.
|
|
|
+ let v = h<4 ? y : h==12||h==14 ? x : z; // Fix repeats at h = 12 to 15
|
|
|
+ return ((h&1)? -u : u) + ((h&2)? -v : v);
|
|
|
+}
|
|
|
+
|
|
|
+function grad4( hash, x, y, z, t ) {
|
|
|
+ let h = hash & 31; // Convert low 5 bits of hash code into 32 simple
|
|
|
+ let u = h<24 ? x : y; // gradient directions, and compute dot product.
|
|
|
+ let v = h<16 ? y : z;
|
|
|
+ let w = h<8 ? z : t;
|
|
|
+ return ((h&1)? -u : u) + ((h&2)? -v : v) + ((h&4)? -w : w);
|
|
|
+}
|
|
|
+
|
|
|
+//---------------------------------------------------------------------
|
|
|
+/** 1D float Perlin noise, SL "noise()"
|
|
|
+ */
|
|
|
+export function noise1( x )
|
|
|
+{
|
|
|
+ let ix0, ix1;
|
|
|
+ let fx0, fx1;
|
|
|
+ let s, n0, n1;
|
|
|
+
|
|
|
+ ix0 = Math.floor( x ); // Integer part of x
|
|
|
+ fx0 = x - ix0; // Fractional part of x
|
|
|
+ fx1 = fx0 - 1.0;
|
|
|
+ ix1 = ( ix0+1 ) & 0xff;
|
|
|
+ ix0 = ix0 & 0xff; // Wrap to 0..255
|
|
|
+
|
|
|
+ s = fade( fx0 );
|
|
|
+
|
|
|
+ n0 = grad1( perm[ ix0 ], fx0 );
|
|
|
+ n1 = grad1( perm[ ix1 ], fx1 );
|
|
|
+ return scale(0.188 * ( lerp( s, n0, n1 ) ));
|
|
|
+}
|
|
|
+
|
|
|
+//---------------------------------------------------------------------
|
|
|
+/** 1D float Perlin periodic noise, SL "pnoise()"
|
|
|
+ */
|
|
|
+export function pnoise1( x, px )
|
|
|
+{
|
|
|
+ let ix0, ix1;
|
|
|
+ let fx0, fx1;
|
|
|
+ let s, n0, n1;
|
|
|
+
|
|
|
+ ix0 = Math.floor( x ); // Integer part of x
|
|
|
+ fx0 = x - ix0; // Fractional part of x
|
|
|
+ fx1 = fx0 - 1.0;
|
|
|
+ ix1 = (( ix0 + 1 ) % px) & 0xff; // Wrap to 0..px-1 *and* wrap to 0..255
|
|
|
+ ix0 = ( ix0 % px ) & 0xff; // (because px might be greater than 256)
|
|
|
+
|
|
|
+ s = fade( fx0 );
|
|
|
+
|
|
|
+ n0 = grad1( perm[ ix0 ], fx0 );
|
|
|
+ n1 = grad1( perm[ ix1 ], fx1 );
|
|
|
+ return scale(0.188 * ( lerp( s, n0, n1 ) ));
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+//---------------------------------------------------------------------
|
|
|
+/** 2D float Perlin noise.
|
|
|
+ */
|
|
|
+export function noise2( x, y )
|
|
|
+{
|
|
|
+ let ix0, iy0, ix1, iy1;
|
|
|
+ let fx0, fy0, fx1, fy1;
|
|
|
+ let s, t, nx0, nx1, n0, n1;
|
|
|
+
|
|
|
+ ix0 = Math.floor( x ); // Integer part of x
|
|
|
+ iy0 = Math.floor( y ); // Integer part of y
|
|
|
+ fx0 = x - ix0; // Fractional part of x
|
|
|
+ fy0 = y - iy0; // Fractional part of y
|
|
|
+ fx1 = fx0 - 1.0;
|
|
|
+ fy1 = fy0 - 1.0;
|
|
|
+ ix1 = (ix0 + 1) & 0xff; // Wrap to 0..255
|
|
|
+ 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 scale(0.507 * ( lerp( s, n0, n1 ) ));
|
|
|
+}
|
|
|
+
|
|
|
+//---------------------------------------------------------------------
|
|
|
+/** 2D float Perlin periodic noise.
|
|
|
+ */
|
|
|
+export function pnoise2( x, y, px, py )
|
|
|
+{
|
|
|
+ let ix0, iy0, ix1, iy1;
|
|
|
+ let fx0, fy0, fx1, fy1;
|
|
|
+ let s, t, nx0, nx1, n0, n1;
|
|
|
+
|
|
|
+ ix0 = Math.floor( x ); // Integer part of x
|
|
|
+ iy0 = Math.floor( y ); // Integer part of y
|
|
|
+ fx0 = x - ix0; // Fractional part of x
|
|
|
+ fy0 = y - iy0; // Fractional part of y
|
|
|
+ fx1 = fx0 - 1.0;
|
|
|
+ fy1 = fy0 - 1.0;
|
|
|
+ ix1 = (( ix0 + 1 ) % px) & 0xff; // Wrap to 0..px-1 and wrap to 0..255
|
|
|
+ iy1 = (( iy0 + 1 ) % py) & 0xff; // Wrap to 0..py-1 and wrap to 0..255
|
|
|
+ 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 scale(0.507 * ( lerp( s, n0, n1 ) ));
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+//---------------------------------------------------------------------
|
|
|
+/** 3D float Perlin noise.
|
|
|
+ */
|
|
|
+export function noise3( x, y, z )
|
|
|
+{
|
|
|
+ let ix0, iy0, ix1, iy1, iz0, iz1;
|
|
|
+ let fx0, fy0, fz0, fx1, fy1, fz1;
|
|
|
+ let s, t, r;
|
|
|
+ let nxy0, nxy1, nx0, nx1, n0, n1;
|
|
|
+
|
|
|
+ ix0 = Math.floor( x ); // Integer part of x
|
|
|
+ iy0 = Math.floor( y ); // Integer part of y
|
|
|
+ iz0 = Math.floor( z ); // Integer part of z
|
|
|
+ fx0 = x - ix0; // Fractional part of x
|
|
|
+ fy0 = y - iy0; // Fractional part of y
|
|
|
+ fz0 = z - iz0; // Fractional part of z
|
|
|
+ fx1 = fx0 - 1.0;
|
|
|
+ fy1 = fy0 - 1.0;
|
|
|
+ fz1 = fz0 - 1.0;
|
|
|
+ ix1 = ( ix0 + 1 ) & 0xff; // Wrap to 0..255
|
|
|
+ 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 scale(0.936 * ( lerp( s, n0, n1 ) ));
|
|
|
+}
|
|
|
+
|
|
|
+//---------------------------------------------------------------------
|
|
|
+/** 3D float Perlin periodic noise.
|
|
|
+ */
|
|
|
+export function pnoise3( x, y, z, px, py, pz )
|
|
|
+{
|
|
|
+ let ix0, iy0, ix1, iy1, iz0, iz1;
|
|
|
+ let fx0, fy0, fz0, fx1, fy1, fz1;
|
|
|
+ let s, t, r;
|
|
|
+ let nxy0, nxy1, nx0, nx1, n0, n1;
|
|
|
+
|
|
|
+ ix0 = Math.floor( x ); // Integer part of x
|
|
|
+ iy0 = Math.floor( y ); // Integer part of y
|
|
|
+ iz0 = Math.floor( z ); // Integer part of z
|
|
|
+ fx0 = x - ix0; // Fractional part of x
|
|
|
+ fy0 = y - iy0; // Fractional part of y
|
|
|
+ fz0 = z - iz0; // Fractional part of z
|
|
|
+ fx1 = fx0 - 1.0;
|
|
|
+ fy1 = fy0 - 1.0;
|
|
|
+ fz1 = fz0 - 1.0;
|
|
|
+ ix1 = (( ix0 + 1 ) % px ) & 0xff; // Wrap to 0..px-1 and wrap to 0..255
|
|
|
+ iy1 = (( iy0 + 1 ) % py ) & 0xff; // Wrap to 0..py-1 and wrap to 0..255
|
|
|
+ iz1 = (( iz0 + 1 ) % pz ) & 0xff; // Wrap to 0..pz-1 and wrap to 0..255
|
|
|
+ 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 scale(0.936 * ( lerp( s, n0, n1 ) ));
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+//---------------------------------------------------------------------
|
|
|
+/** 4D float Perlin noise.
|
|
|
+ */
|
|
|
+
|
|
|
+export function noise4( x, y, z, w )
|
|
|
+{
|
|
|
+ let ix0, iy0, iz0, iw0, ix1, iy1, iz1, iw1;
|
|
|
+ let fx0, fy0, fz0, fw0, fx1, fy1, fz1, fw1;
|
|
|
+ let s, t, r, q;
|
|
|
+ let nxyz0, nxyz1, nxy0, nxy1, nx0, nx1, n0, n1;
|
|
|
+
|
|
|
+ ix0 = Math.floor( x ); // Integer part of x
|
|
|
+ iy0 = Math.floor( y ); // Integer part of y
|
|
|
+ iz0 = Math.floor( z ); // Integer part of y
|
|
|
+ iw0 = Math.floor( w ); // Integer part of w
|
|
|
+ fx0 = x - ix0; // Fractional part of x
|
|
|
+ fy0 = y - iy0; // Fractional part of y
|
|
|
+ fz0 = z - iz0; // Fractional part of z
|
|
|
+ fw0 = w - iw0; // Fractional part of w
|
|
|
+ fx1 = fx0 - 1.0;
|
|
|
+ fy1 = fy0 - 1.0;
|
|
|
+ fz1 = fz0 - 1.0;
|
|
|
+ fw1 = fw0 - 1.0;
|
|
|
+ ix1 = ( ix0 + 1 ) & 0xff; // Wrap to 0..255
|
|
|
+ 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 scale(0.87 * ( lerp( s, n0, n1 ) ));
|
|
|
+}
|
|
|
+
|
|
|
+//---------------------------------------------------------------------
|
|
|
+/** 4D float Perlin periodic noise.
|
|
|
+ */
|
|
|
+
|
|
|
+export function pnoise4( x, y, z, w,
|
|
|
+ px, py, pz, pw )
|
|
|
+{
|
|
|
+ let ix0, iy0, iz0, iw0, ix1, iy1, iz1, iw1;
|
|
|
+ let fx0, fy0, fz0, fw0, fx1, fy1, fz1, fw1;
|
|
|
+ let s, t, r, q;
|
|
|
+ let nxyz0, nxyz1, nxy0, nxy1, nx0, nx1, n0, n1;
|
|
|
+
|
|
|
+ ix0 = Math.floor( x ); // Integer part of x
|
|
|
+ iy0 = Math.floor( y ); // Integer part of y
|
|
|
+ iz0 = Math.floor( z ); // Integer part of y
|
|
|
+ iw0 = Math.floor( w ); // Integer part of w
|
|
|
+ fx0 = x - ix0; // Fractional part of x
|
|
|
+ fy0 = y - iy0; // Fractional part of y
|
|
|
+ fz0 = z - iz0; // Fractional part of z
|
|
|
+ fw0 = w - iw0; // Fractional part of w
|
|
|
+ fx1 = fx0 - 1.0;
|
|
|
+ fy1 = fy0 - 1.0;
|
|
|
+ fz1 = fz0 - 1.0;
|
|
|
+ fw1 = fw0 - 1.0;
|
|
|
+ ix1 = (( ix0 + 1 ) % px ) & 0xff; // Wrap to 0..px-1 and wrap to 0..255
|
|
|
+ iy1 = (( iy0 + 1 ) % py ) & 0xff; // Wrap to 0..py-1 and wrap to 0..255
|
|
|
+ iz1 = (( iz0 + 1 ) % pz ) & 0xff; // Wrap to 0..pz-1 and wrap to 0..255
|
|
|
+ iw1 = (( iw0 + 1 ) % pw ) & 0xff; // Wrap to 0..pw-1 and wrap to 0..255
|
|
|
+ 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 scale(0.87 * ( lerp( s, n0, n1 ) ));
|
|
|
+}
|
|
|
+
|
|
|
+function scale(n) {
|
|
|
+ return (1 + n) / 2;
|
|
|
+}
|
|
|
+
|
|
|
+export default function noise(x, y, z, w) {
|
|
|
+
|
|
|
+ switch(arguments.length) {
|
|
|
+ case 1:
|
|
|
+ return noise1(x); //todo: move these to perlin functions
|
|
|
+ break;
|
|
|
+ case 2:
|
|
|
+ return noise2(x, y); //todo: move these to perlin functions
|
|
|
+ break;
|
|
|
+ case 3:
|
|
|
+ return noise3(x, y, z);
|
|
|
+ case 3:
|
|
|
+ return noise4(x, y, z, w);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+//---------------------------------------------------------------------
|
simondevyoutube
