Attachment 87819 Details for Bug 70613 – half second compile

half second compile

fast_compile.frag.glsl (text/plain), 104.59 KB, created by Kevin Rogovin on 2013-10-18 11:39:12 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Kevin Rogovin

Created: 2013-10-18 11:39:12 UTC

Size: 104.59 KB

patch

obsolete

>
>#define WRATH_GL_FRAGMENT_SHADER
>                                                                     //LOCATION(  1, raw string)
>#define GREY_SCALE_NOISE                                             //LOCATION(  2, raw string)
>                                                                     //LOCATION(  1, raw string)
>#define PERLIN_PERIOD 4                                              //LOCATION(  2, raw string)
>                                                                     //LOCATION(  1, raw string)
>#define CoordMultiplier 16                                           //LOCATION(  2, raw string)
>                                                                     //LOCATION(  1, raw string)
>#define CircleRadius 2                                               //LOCATION(  2, raw string)
>/*                                                                   //LOCATION(  1, noise/shaders/common.glsl)
>define perlin noise with same interface as others                    //LOCATION(  2, noise/shaders/common.glsl)
>*/                                                                   //LOCATION(  3, noise/shaders/common.glsl)
>                                                                     //LOCATION(  4, noise/shaders/common.glsl)
>                                                                     //LOCATION(  5, noise/shaders/common.glsl)
>float pnoise(vec2, vec2);                                            //LOCATION(  6, noise/shaders/common.glsl)
>float pnoise(vec2 v)                                                 //LOCATION(  7, noise/shaders/common.glsl)
>{                                                                    //LOCATION(  8, noise/shaders/common.glsl)
>	return pnoise(v, vec2(PERLIN_PERIOD,                                //LOCATION(  9, noise/shaders/common.glsl)
>	                      PERLIN_PERIOD));                              //LOCATION( 10, noise/shaders/common.glsl)
>}                                                                    //LOCATION( 11, noise/shaders/common.glsl)
>                                                                     //LOCATION( 12, noise/shaders/common.glsl)
>                                                                     //LOCATION( 13, noise/shaders/common.glsl)
>float pnoise(vec3, vec3);                                            //LOCATION( 14, noise/shaders/common.glsl)
>float pnoise(vec3 v)                                                 //LOCATION( 15, noise/shaders/common.glsl)
>{                                                                    //LOCATION( 16, noise/shaders/common.glsl)
>	return pnoise(v, vec3(PERLIN_PERIOD,                                //LOCATION( 17, noise/shaders/common.glsl)
>	                      PERLIN_PERIOD,                                //LOCATION( 18, noise/shaders/common.glsl)
>			      PERLIN_PERIOD));                                            //LOCATION( 19, noise/shaders/common.glsl)
>}                                                                    //LOCATION( 20, noise/shaders/common.glsl)
>                                                                     //LOCATION( 21, noise/shaders/common.glsl)
>                                                                     //LOCATION( 22, noise/shaders/common.glsl)
>float pnoise(vec4, vec4);                                            //LOCATION( 23, noise/shaders/common.glsl)
>float pnoise(vec4 v)                                                 //LOCATION( 24, noise/shaders/common.glsl)
>{                                                                    //LOCATION( 25, noise/shaders/common.glsl)
>	return pnoise(v, vec4(PERLIN_PERIOD,                                //LOCATION( 26, noise/shaders/common.glsl)
>	                      PERLIN_PERIOD,                                //LOCATION( 27, noise/shaders/common.glsl)
>			      PERLIN_PERIOD,                                              //LOCATION( 28, noise/shaders/common.glsl)
>			      PERLIN_PERIOD));                                            //LOCATION( 29, noise/shaders/common.glsl)
>}                                                                    //LOCATION( 30, noise/shaders/common.glsl)
>                                                                     //LOCATION( 31, noise/shaders/common.glsl)
>/*                                                                   //LOCATION( 32, noise/shaders/common.glsl)
>  Common utility functions used.                                     //LOCATION( 33, noise/shaders/common.glsl)
>*/                                                                   //LOCATION( 34, noise/shaders/common.glsl)
>#define MAKE_MOD289(TYPE) TYPE mod289(TYPE x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }  //LOCATION( 35, noise/shaders/common.glsl)
>MAKE_MOD289(float)                                                   //LOCATION( 36, noise/shaders/common.glsl)
>MAKE_MOD289(vec2)                                                    //LOCATION( 37, noise/shaders/common.glsl)
>MAKE_MOD289(vec3)                                                    //LOCATION( 38, noise/shaders/common.glsl)
>MAKE_MOD289(vec4)                                                    //LOCATION( 39, noise/shaders/common.glsl)
>#undef MAKE_MOD289                                                   //LOCATION( 40, noise/shaders/common.glsl)
>                                                                     //LOCATION( 41, noise/shaders/common.glsl)
>                                                                     //LOCATION( 42, noise/shaders/common.glsl)
>#define MAKE_PERMUTE(TYPE) TYPE permute(TYPE x) { return mod289(((x*34.0)+1.0)*x); }  //LOCATION( 43, noise/shaders/common.glsl)
>MAKE_PERMUTE(float)                                                  //LOCATION( 44, noise/shaders/common.glsl)
>MAKE_PERMUTE(vec2)                                                   //LOCATION( 45, noise/shaders/common.glsl)
>MAKE_PERMUTE(vec3)                                                   //LOCATION( 46, noise/shaders/common.glsl)
>MAKE_PERMUTE(vec4)                                                   //LOCATION( 47, noise/shaders/common.glsl)
>#undef MAKE_PERMUTE                                                  //LOCATION( 48, noise/shaders/common.glsl)
>                                                                     //LOCATION( 49, noise/shaders/common.glsl)
>#define MAKE_TAYLORINVSQRT(TYPE) TYPE taylorInvSqrt(TYPE r) { return 1.79284291400159 - 0.85373472095314 * r; }  //LOCATION( 50, noise/shaders/common.glsl)
>MAKE_TAYLORINVSQRT(float)                                            //LOCATION( 51, noise/shaders/common.glsl)
>MAKE_TAYLORINVSQRT(vec2)                                             //LOCATION( 52, noise/shaders/common.glsl)
>MAKE_TAYLORINVSQRT(vec3)                                             //LOCATION( 53, noise/shaders/common.glsl)
>MAKE_TAYLORINVSQRT(vec4)                                             //LOCATION( 54, noise/shaders/common.glsl)
>#undef MAKE_TAYLORINVSQRT                                            //LOCATION( 55, noise/shaders/common.glsl)
>                                                                     //LOCATION( 56, noise/shaders/common.glsl)
>#define MAKE_FADE(TYPE) TYPE fade(TYPE t) { return t*t*t*(t*(t*6.0-15.0)+10.0); }  //LOCATION( 57, noise/shaders/common.glsl)
>MAKE_FADE(float)                                                     //LOCATION( 58, noise/shaders/common.glsl)
>MAKE_FADE(vec2)                                                      //LOCATION( 59, noise/shaders/common.glsl)
>MAKE_FADE(vec3)                                                      //LOCATION( 60, noise/shaders/common.glsl)
>MAKE_FADE(vec4)                                                      //LOCATION( 61, noise/shaders/common.glsl)
>#undef MAKE_FADE                                                     //LOCATION( 62, noise/shaders/common.glsl)
>                                                                     //LOCATION( 63, noise/shaders/common.glsl)
>float time_dependent(void);                                          //LOCATION( 64, noise/shaders/common.glsl)
>//                                                                   //LOCATION(  1, noise/shaders/classicnoise2D.glsl)
>// GLSL textureless classic 2D noise "cnoise",                       //LOCATION(  2, noise/shaders/classicnoise2D.glsl)
>// with an RSL-style periodic variant "pnoise".                      //LOCATION(  3, noise/shaders/classicnoise2D.glsl)
>// Author:  Stefan Gustavson (stefan.gustavson@liu.se)               //LOCATION(  4, noise/shaders/classicnoise2D.glsl)
>// Version: 2011-08-22                                               //LOCATION(  5, noise/shaders/classicnoise2D.glsl)
>//                                                                   //LOCATION(  6, noise/shaders/classicnoise2D.glsl)
>// Many thanks to Ian McEwan of Ashima Arts for the                  //LOCATION(  7, noise/shaders/classicnoise2D.glsl)
>// ideas for permutation and gradient selection.                     //LOCATION(  8, noise/shaders/classicnoise2D.glsl)
>//                                                                   //LOCATION(  9, noise/shaders/classicnoise2D.glsl)
>// Copyright (c) 2011 Stefan Gustavson. All rights reserved.         //LOCATION( 10, noise/shaders/classicnoise2D.glsl)
>// Distributed under the MIT license. See LICENSE file.              //LOCATION( 11, noise/shaders/classicnoise2D.glsl)
>// https://github.com/ashima/webgl-noise                             //LOCATION( 12, noise/shaders/classicnoise2D.glsl)
>//                                                                   //LOCATION( 13, noise/shaders/classicnoise2D.glsl)
>                                                                     //LOCATION( 14, noise/shaders/classicnoise2D.glsl)
>                                                                     //LOCATION( 15, noise/shaders/classicnoise2D.glsl)
>// Classic Perlin noise                                              //LOCATION( 16, noise/shaders/classicnoise2D.glsl)
>float cnoise(vec2 P)                                                 //LOCATION( 17, noise/shaders/classicnoise2D.glsl)
>{                                                                    //LOCATION( 18, noise/shaders/classicnoise2D.glsl)
>  vec4 Pi = floor(P.xyxy) + vec4(0.0, 0.0, 1.0, 1.0);                //LOCATION( 19, noise/shaders/classicnoise2D.glsl)
>  vec4 Pf = fract(P.xyxy) - vec4(0.0, 0.0, 1.0, 1.0);                //LOCATION( 20, noise/shaders/classicnoise2D.glsl)
>  Pi = mod289(Pi); // To avoid truncation effects in permutation     //LOCATION( 21, noise/shaders/classicnoise2D.glsl)
>  vec4 ix = Pi.xzxz;                                                 //LOCATION( 22, noise/shaders/classicnoise2D.glsl)
>  vec4 iy = Pi.yyww;                                                 //LOCATION( 23, noise/shaders/classicnoise2D.glsl)
>  vec4 fx = Pf.xzxz;                                                 //LOCATION( 24, noise/shaders/classicnoise2D.glsl)
>  vec4 fy = Pf.yyww;                                                 //LOCATION( 25, noise/shaders/classicnoise2D.glsl)
>                                                                     //LOCATION( 26, noise/shaders/classicnoise2D.glsl)
>  vec4 i = permute(permute(ix) + iy);                                //LOCATION( 27, noise/shaders/classicnoise2D.glsl)
>                                                                     //LOCATION( 28, noise/shaders/classicnoise2D.glsl)
>  vec4 gx = fract(i * (1.0 / 41.0)) * 2.0 - 1.0 ;                    //LOCATION( 29, noise/shaders/classicnoise2D.glsl)
>  vec4 gy = abs(gx) - 0.5 ;                                          //LOCATION( 30, noise/shaders/classicnoise2D.glsl)
>  vec4 tx = floor(gx + 0.5);                                         //LOCATION( 31, noise/shaders/classicnoise2D.glsl)
>  gx = gx - tx;                                                      //LOCATION( 32, noise/shaders/classicnoise2D.glsl)
>                                                                     //LOCATION( 33, noise/shaders/classicnoise2D.glsl)
>  vec2 g00 = vec2(gx.x,gy.x);                                        //LOCATION( 34, noise/shaders/classicnoise2D.glsl)
>  vec2 g10 = vec2(gx.y,gy.y);                                        //LOCATION( 35, noise/shaders/classicnoise2D.glsl)
>  vec2 g01 = vec2(gx.z,gy.z);                                        //LOCATION( 36, noise/shaders/classicnoise2D.glsl)
>  vec2 g11 = vec2(gx.w,gy.w);                                        //LOCATION( 37, noise/shaders/classicnoise2D.glsl)
>                                                                     //LOCATION( 38, noise/shaders/classicnoise2D.glsl)
>  vec4 norm = taylorInvSqrt(vec4(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));  //LOCATION( 39, noise/shaders/classicnoise2D.glsl)
>  g00 *= norm.x;                                                     //LOCATION( 40, noise/shaders/classicnoise2D.glsl)
>  g01 *= norm.y;                                                     //LOCATION( 41, noise/shaders/classicnoise2D.glsl)
>  g10 *= norm.z;                                                     //LOCATION( 42, noise/shaders/classicnoise2D.glsl)
>  g11 *= norm.w;                                                     //LOCATION( 43, noise/shaders/classicnoise2D.glsl)
>                                                                     //LOCATION( 44, noise/shaders/classicnoise2D.glsl)
>  float n00 = dot(g00, vec2(fx.x, fy.x));                            //LOCATION( 45, noise/shaders/classicnoise2D.glsl)
>  float n10 = dot(g10, vec2(fx.y, fy.y));                            //LOCATION( 46, noise/shaders/classicnoise2D.glsl)
>  float n01 = dot(g01, vec2(fx.z, fy.z));                            //LOCATION( 47, noise/shaders/classicnoise2D.glsl)
>  float n11 = dot(g11, vec2(fx.w, fy.w));                            //LOCATION( 48, noise/shaders/classicnoise2D.glsl)
>                                                                     //LOCATION( 49, noise/shaders/classicnoise2D.glsl)
>  vec2 fade_xy = fade(Pf.xy);                                        //LOCATION( 50, noise/shaders/classicnoise2D.glsl)
>  vec2 n_x = mix(vec2(n00, n01), vec2(n10, n11), fade_xy.x);         //LOCATION( 51, noise/shaders/classicnoise2D.glsl)
>  float n_xy = mix(n_x.x, n_x.y, fade_xy.y);                         //LOCATION( 52, noise/shaders/classicnoise2D.glsl)
>  return 2.3 * n_xy;                                                 //LOCATION( 53, noise/shaders/classicnoise2D.glsl)
>}                                                                    //LOCATION( 54, noise/shaders/classicnoise2D.glsl)
>                                                                     //LOCATION( 55, noise/shaders/classicnoise2D.glsl)
>// Classic Perlin noise, periodic variant                            //LOCATION( 56, noise/shaders/classicnoise2D.glsl)
>float pnoise(vec2 P, vec2 rep)                                       //LOCATION( 57, noise/shaders/classicnoise2D.glsl)
>{                                                                    //LOCATION( 58, noise/shaders/classicnoise2D.glsl)
>  vec4 Pi = floor(P.xyxy) + vec4(0.0, 0.0, 1.0, 1.0);                //LOCATION( 59, noise/shaders/classicnoise2D.glsl)
>  vec4 Pf = fract(P.xyxy) - vec4(0.0, 0.0, 1.0, 1.0);                //LOCATION( 60, noise/shaders/classicnoise2D.glsl)
>  Pi = mod(Pi, rep.xyxy); // To create noise with explicit period    //LOCATION( 61, noise/shaders/classicnoise2D.glsl)
>  Pi = mod289(Pi);        // To avoid truncation effects in permutation  //LOCATION( 62, noise/shaders/classicnoise2D.glsl)
>  vec4 ix = Pi.xzxz;                                                 //LOCATION( 63, noise/shaders/classicnoise2D.glsl)
>  vec4 iy = Pi.yyww;                                                 //LOCATION( 64, noise/shaders/classicnoise2D.glsl)
>  vec4 fx = Pf.xzxz;                                                 //LOCATION( 65, noise/shaders/classicnoise2D.glsl)
>  vec4 fy = Pf.yyww;                                                 //LOCATION( 66, noise/shaders/classicnoise2D.glsl)
>                                                                     //LOCATION( 67, noise/shaders/classicnoise2D.glsl)
>  vec4 i = permute(permute(ix) + iy);                                //LOCATION( 68, noise/shaders/classicnoise2D.glsl)
>                                                                     //LOCATION( 69, noise/shaders/classicnoise2D.glsl)
>  vec4 gx = fract(i * (1.0 / 41.0)) * 2.0 - 1.0 ;                    //LOCATION( 70, noise/shaders/classicnoise2D.glsl)
>  vec4 gy = abs(gx) - 0.5 ;                                          //LOCATION( 71, noise/shaders/classicnoise2D.glsl)
>  vec4 tx = floor(gx + 0.5);                                         //LOCATION( 72, noise/shaders/classicnoise2D.glsl)
>  gx = gx - tx;                                                      //LOCATION( 73, noise/shaders/classicnoise2D.glsl)
>                                                                     //LOCATION( 74, noise/shaders/classicnoise2D.glsl)
>  vec2 g00 = vec2(gx.x,gy.x);                                        //LOCATION( 75, noise/shaders/classicnoise2D.glsl)
>  vec2 g10 = vec2(gx.y,gy.y);                                        //LOCATION( 76, noise/shaders/classicnoise2D.glsl)
>  vec2 g01 = vec2(gx.z,gy.z);                                        //LOCATION( 77, noise/shaders/classicnoise2D.glsl)
>  vec2 g11 = vec2(gx.w,gy.w);                                        //LOCATION( 78, noise/shaders/classicnoise2D.glsl)
>                                                                     //LOCATION( 79, noise/shaders/classicnoise2D.glsl)
>  vec4 norm = taylorInvSqrt(vec4(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));  //LOCATION( 80, noise/shaders/classicnoise2D.glsl)
>  g00 *= norm.x;                                                     //LOCATION( 81, noise/shaders/classicnoise2D.glsl)
>  g01 *= norm.y;                                                     //LOCATION( 82, noise/shaders/classicnoise2D.glsl)
>  g10 *= norm.z;                                                     //LOCATION( 83, noise/shaders/classicnoise2D.glsl)
>  g11 *= norm.w;                                                     //LOCATION( 84, noise/shaders/classicnoise2D.glsl)
>                                                                     //LOCATION( 85, noise/shaders/classicnoise2D.glsl)
>  float n00 = dot(g00, vec2(fx.x, fy.x));                            //LOCATION( 86, noise/shaders/classicnoise2D.glsl)
>  float n10 = dot(g10, vec2(fx.y, fy.y));                            //LOCATION( 87, noise/shaders/classicnoise2D.glsl)
>  float n01 = dot(g01, vec2(fx.z, fy.z));                            //LOCATION( 88, noise/shaders/classicnoise2D.glsl)
>  float n11 = dot(g11, vec2(fx.w, fy.w));                            //LOCATION( 89, noise/shaders/classicnoise2D.glsl)
>                                                                     //LOCATION( 90, noise/shaders/classicnoise2D.glsl)
>  vec2 fade_xy = fade(Pf.xy);                                        //LOCATION( 91, noise/shaders/classicnoise2D.glsl)
>  vec2 n_x = mix(vec2(n00, n01), vec2(n10, n11), fade_xy.x);         //LOCATION( 92, noise/shaders/classicnoise2D.glsl)
>  float n_xy = mix(n_x.x, n_x.y, fade_xy.y);                         //LOCATION( 93, noise/shaders/classicnoise2D.glsl)
>  return 2.3 * n_xy;                                                 //LOCATION( 94, noise/shaders/classicnoise2D.glsl)
>}                                                                    //LOCATION( 95, noise/shaders/classicnoise2D.glsl)
>//                                                                   //LOCATION(  1, noise/shaders/noise2D.glsl)
>// Description : Array and textureless GLSL 2D simplex noise function.  //LOCATION(  2, noise/shaders/noise2D.glsl)
>//      Author : Ian McEwan, Ashima Arts.                            //LOCATION(  3, noise/shaders/noise2D.glsl)
>//  Maintainer : ijm                                                 //LOCATION(  4, noise/shaders/noise2D.glsl)
>//     Lastmod : 20110822 (ijm)                                      //LOCATION(  5, noise/shaders/noise2D.glsl)
>//     License : Copyright (C) 2011 Ashima Arts. All rights reserved.  //LOCATION(  6, noise/shaders/noise2D.glsl)
>//               Distributed under the MIT License. See LICENSE file.  //LOCATION(  7, noise/shaders/noise2D.glsl)
>//               https://github.com/ashima/webgl-noise               //LOCATION(  8, noise/shaders/noise2D.glsl)
>//                                                                   //LOCATION(  9, noise/shaders/noise2D.glsl)
>                                                                     //LOCATION( 10, noise/shaders/noise2D.glsl)
>                                                                     //LOCATION( 11, noise/shaders/noise2D.glsl)
>                                                                     //LOCATION( 12, noise/shaders/noise2D.glsl)
>float snoise(vec2 v)                                                 //LOCATION( 13, noise/shaders/noise2D.glsl)
>  {                                                                  //LOCATION( 14, noise/shaders/noise2D.glsl)
>  const vec4 C = vec4(0.211324865405187,  // (3.0-sqrt(3.0))/6.0     //LOCATION( 15, noise/shaders/noise2D.glsl)
>                      0.366025403784439,  // 0.5*(sqrt(3.0)-1.0)     //LOCATION( 16, noise/shaders/noise2D.glsl)
>                     -0.577350269189626,  // -1.0 + 2.0 * C.x        //LOCATION( 17, noise/shaders/noise2D.glsl)
>                      0.024390243902439); // 1.0 / 41.0              //LOCATION( 18, noise/shaders/noise2D.glsl)
>// First corner                                                      //LOCATION( 19, noise/shaders/noise2D.glsl)
>  vec2 i  = floor(v + dot(v, C.yy) );                                //LOCATION( 20, noise/shaders/noise2D.glsl)
>  vec2 x0 = v -   i + dot(i, C.xx);                                  //LOCATION( 21, noise/shaders/noise2D.glsl)
>                                                                     //LOCATION( 22, noise/shaders/noise2D.glsl)
>// Other corners                                                     //LOCATION( 23, noise/shaders/noise2D.glsl)
>  vec2 i1;                                                           //LOCATION( 24, noise/shaders/noise2D.glsl)
>  //i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0            //LOCATION( 25, noise/shaders/noise2D.glsl)
>  //i1.y = 1.0 - i1.x;                                               //LOCATION( 26, noise/shaders/noise2D.glsl)
>  i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);              //LOCATION( 27, noise/shaders/noise2D.glsl)
>  // x0 = x0 - 0.0 + 0.0 * C.xx ;                                    //LOCATION( 28, noise/shaders/noise2D.glsl)
>  // x1 = x0 - i1 + 1.0 * C.xx ;                                     //LOCATION( 29, noise/shaders/noise2D.glsl)
>  // x2 = x0 - 1.0 + 2.0 * C.xx ;                                    //LOCATION( 30, noise/shaders/noise2D.glsl)
>  vec4 x12 = x0.xyxy + C.xxzz;                                       //LOCATION( 31, noise/shaders/noise2D.glsl)
>  x12.xy -= i1;                                                      //LOCATION( 32, noise/shaders/noise2D.glsl)
>                                                                     //LOCATION( 33, noise/shaders/noise2D.glsl)
>// Permutations                                                      //LOCATION( 34, noise/shaders/noise2D.glsl)
>  i = mod289(i); // Avoid truncation effects in permutation          //LOCATION( 35, noise/shaders/noise2D.glsl)
>  vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 ))            //LOCATION( 36, noise/shaders/noise2D.glsl)
>		+ i.x + vec3(0.0, i1.x, 1.0 ));                                    //LOCATION( 37, noise/shaders/noise2D.glsl)
>                                                                     //LOCATION( 38, noise/shaders/noise2D.glsl)
>  vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0);  //LOCATION( 39, noise/shaders/noise2D.glsl)
>  m = m*m ;                                                          //LOCATION( 40, noise/shaders/noise2D.glsl)
>  m = m*m ;                                                          //LOCATION( 41, noise/shaders/noise2D.glsl)
>                                                                     //LOCATION( 42, noise/shaders/noise2D.glsl)
>// Gradients: 41 points uniformly over a line, mapped onto a diamond.  //LOCATION( 43, noise/shaders/noise2D.glsl)
>// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)  //LOCATION( 44, noise/shaders/noise2D.glsl)
>                                                                     //LOCATION( 45, noise/shaders/noise2D.glsl)
>  vec3 x = 2.0 * fract(p * C.www) - 1.0;                             //LOCATION( 46, noise/shaders/noise2D.glsl)
>  vec3 h = abs(x) - 0.5;                                             //LOCATION( 47, noise/shaders/noise2D.glsl)
>  vec3 ox = floor(x + 0.5);                                          //LOCATION( 48, noise/shaders/noise2D.glsl)
>  vec3 a0 = x - ox;                                                  //LOCATION( 49, noise/shaders/noise2D.glsl)
>                                                                     //LOCATION( 50, noise/shaders/noise2D.glsl)
>// Normalise gradients implicitly by scaling m                       //LOCATION( 51, noise/shaders/noise2D.glsl)
>// Approximation of: m *= inversesqrt( a0*a0 + h*h );                //LOCATION( 52, noise/shaders/noise2D.glsl)
>  m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h );        //LOCATION( 53, noise/shaders/noise2D.glsl)
>                                                                     //LOCATION( 54, noise/shaders/noise2D.glsl)
>// Compute final noise value at P                                    //LOCATION( 55, noise/shaders/noise2D.glsl)
>  vec3 g;                                                            //LOCATION( 56, noise/shaders/noise2D.glsl)
>  g.x  = a0.x  * x0.x  + h.x  * x0.y;                                //LOCATION( 57, noise/shaders/noise2D.glsl)
>  g.yz = a0.yz * x12.xz + h.yz * x12.yw;                             //LOCATION( 58, noise/shaders/noise2D.glsl)
>  return 130.0 * dot(m, g);                                          //LOCATION( 59, noise/shaders/noise2D.glsl)
>}                                                                    //LOCATION( 60, noise/shaders/noise2D.glsl)
>//                                                                   //LOCATION(  1, noise/shaders/classicnoise3D.glsl)
>// GLSL textureless classic 3D noise "cnoise",                       //LOCATION(  2, noise/shaders/classicnoise3D.glsl)
>// with an RSL-style periodic variant "pnoise".                      //LOCATION(  3, noise/shaders/classicnoise3D.glsl)
>// Author:  Stefan Gustavson (stefan.gustavson@liu.se)               //LOCATION(  4, noise/shaders/classicnoise3D.glsl)
>// Version: 2011-10-11                                               //LOCATION(  5, noise/shaders/classicnoise3D.glsl)
>//                                                                   //LOCATION(  6, noise/shaders/classicnoise3D.glsl)
>// Many thanks to Ian McEwan of Ashima Arts for the                  //LOCATION(  7, noise/shaders/classicnoise3D.glsl)
>// ideas for permutation and gradient selection.                     //LOCATION(  8, noise/shaders/classicnoise3D.glsl)
>//                                                                   //LOCATION(  9, noise/shaders/classicnoise3D.glsl)
>// Copyright (c) 2011 Stefan Gustavson. All rights reserved.         //LOCATION( 10, noise/shaders/classicnoise3D.glsl)
>// Distributed under the MIT license. See LICENSE file.              //LOCATION( 11, noise/shaders/classicnoise3D.glsl)
>// https://github.com/ashima/webgl-noise                             //LOCATION( 12, noise/shaders/classicnoise3D.glsl)
>//                                                                   //LOCATION( 13, noise/shaders/classicnoise3D.glsl)
>                                                                     //LOCATION( 14, noise/shaders/classicnoise3D.glsl)
>                                                                     //LOCATION( 15, noise/shaders/classicnoise3D.glsl)
>                                                                     //LOCATION( 16, noise/shaders/classicnoise3D.glsl)
>// Classic Perlin noise                                              //LOCATION( 17, noise/shaders/classicnoise3D.glsl)
>float cnoise(vec3 P)                                                 //LOCATION( 18, noise/shaders/classicnoise3D.glsl)
>{                                                                    //LOCATION( 19, noise/shaders/classicnoise3D.glsl)
>  vec3 Pi0 = floor(P); // Integer part for indexing                  //LOCATION( 20, noise/shaders/classicnoise3D.glsl)
>  vec3 Pi1 = Pi0 + vec3(1.0); // Integer part + 1                    //LOCATION( 21, noise/shaders/classicnoise3D.glsl)
>  Pi0 = mod289(Pi0);                                                 //LOCATION( 22, noise/shaders/classicnoise3D.glsl)
>  Pi1 = mod289(Pi1);                                                 //LOCATION( 23, noise/shaders/classicnoise3D.glsl)
>  vec3 Pf0 = fract(P); // Fractional part for interpolation          //LOCATION( 24, noise/shaders/classicnoise3D.glsl)
>  vec3 Pf1 = Pf0 - vec3(1.0); // Fractional part - 1.0               //LOCATION( 25, noise/shaders/classicnoise3D.glsl)
>  vec4 ix = vec4(Pi0.x, Pi1.x, Pi0.x, Pi1.x);                        //LOCATION( 26, noise/shaders/classicnoise3D.glsl)
>  vec4 iy = vec4(Pi0.yy, Pi1.yy);                                    //LOCATION( 27, noise/shaders/classicnoise3D.glsl)
>  vec4 iz0 = Pi0.zzzz;                                               //LOCATION( 28, noise/shaders/classicnoise3D.glsl)
>  vec4 iz1 = Pi1.zzzz;                                               //LOCATION( 29, noise/shaders/classicnoise3D.glsl)
>                                                                     //LOCATION( 30, noise/shaders/classicnoise3D.glsl)
>  vec4 ixy = permute(permute(ix) + iy);                              //LOCATION( 31, noise/shaders/classicnoise3D.glsl)
>  vec4 ixy0 = permute(ixy + iz0);                                    //LOCATION( 32, noise/shaders/classicnoise3D.glsl)
>  vec4 ixy1 = permute(ixy + iz1);                                    //LOCATION( 33, noise/shaders/classicnoise3D.glsl)
>                                                                     //LOCATION( 34, noise/shaders/classicnoise3D.glsl)
>  vec4 gx0 = ixy0 * (1.0 / 7.0);                                     //LOCATION( 35, noise/shaders/classicnoise3D.glsl)
>  vec4 gy0 = fract(floor(gx0) * (1.0 / 7.0)) - 0.5;                  //LOCATION( 36, noise/shaders/classicnoise3D.glsl)
>  gx0 = fract(gx0);                                                  //LOCATION( 37, noise/shaders/classicnoise3D.glsl)
>  vec4 gz0 = vec4(0.5) - abs(gx0) - abs(gy0);                        //LOCATION( 38, noise/shaders/classicnoise3D.glsl)
>  vec4 sz0 = step(gz0, vec4(0.0));                                   //LOCATION( 39, noise/shaders/classicnoise3D.glsl)
>  gx0 -= sz0 * (step(0.0, gx0) - 0.5);                               //LOCATION( 40, noise/shaders/classicnoise3D.glsl)
>  gy0 -= sz0 * (step(0.0, gy0) - 0.5);                               //LOCATION( 41, noise/shaders/classicnoise3D.glsl)
>                                                                     //LOCATION( 42, noise/shaders/classicnoise3D.glsl)
>  vec4 gx1 = ixy1 * (1.0 / 7.0);                                     //LOCATION( 43, noise/shaders/classicnoise3D.glsl)
>  vec4 gy1 = fract(floor(gx1) * (1.0 / 7.0)) - 0.5;                  //LOCATION( 44, noise/shaders/classicnoise3D.glsl)
>  gx1 = fract(gx1);                                                  //LOCATION( 45, noise/shaders/classicnoise3D.glsl)
>  vec4 gz1 = vec4(0.5) - abs(gx1) - abs(gy1);                        //LOCATION( 46, noise/shaders/classicnoise3D.glsl)
>  vec4 sz1 = step(gz1, vec4(0.0));                                   //LOCATION( 47, noise/shaders/classicnoise3D.glsl)
>  gx1 -= sz1 * (step(0.0, gx1) - 0.5);                               //LOCATION( 48, noise/shaders/classicnoise3D.glsl)
>  gy1 -= sz1 * (step(0.0, gy1) - 0.5);                               //LOCATION( 49, noise/shaders/classicnoise3D.glsl)
>                                                                     //LOCATION( 50, noise/shaders/classicnoise3D.glsl)
>  vec3 g000 = vec3(gx0.x,gy0.x,gz0.x);                               //LOCATION( 51, noise/shaders/classicnoise3D.glsl)
>  vec3 g100 = vec3(gx0.y,gy0.y,gz0.y);                               //LOCATION( 52, noise/shaders/classicnoise3D.glsl)
>  vec3 g010 = vec3(gx0.z,gy0.z,gz0.z);                               //LOCATION( 53, noise/shaders/classicnoise3D.glsl)
>  vec3 g110 = vec3(gx0.w,gy0.w,gz0.w);                               //LOCATION( 54, noise/shaders/classicnoise3D.glsl)
>  vec3 g001 = vec3(gx1.x,gy1.x,gz1.x);                               //LOCATION( 55, noise/shaders/classicnoise3D.glsl)
>  vec3 g101 = vec3(gx1.y,gy1.y,gz1.y);                               //LOCATION( 56, noise/shaders/classicnoise3D.glsl)
>  vec3 g011 = vec3(gx1.z,gy1.z,gz1.z);                               //LOCATION( 57, noise/shaders/classicnoise3D.glsl)
>  vec3 g111 = vec3(gx1.w,gy1.w,gz1.w);                               //LOCATION( 58, noise/shaders/classicnoise3D.glsl)
>                                                                     //LOCATION( 59, noise/shaders/classicnoise3D.glsl)
>  vec4 norm0 = taylorInvSqrt(vec4(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));  //LOCATION( 60, noise/shaders/classicnoise3D.glsl)
>  g000 *= norm0.x;                                                   //LOCATION( 61, noise/shaders/classicnoise3D.glsl)
>  g010 *= norm0.y;                                                   //LOCATION( 62, noise/shaders/classicnoise3D.glsl)
>  g100 *= norm0.z;                                                   //LOCATION( 63, noise/shaders/classicnoise3D.glsl)
>  g110 *= norm0.w;                                                   //LOCATION( 64, noise/shaders/classicnoise3D.glsl)
>  vec4 norm1 = taylorInvSqrt(vec4(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));  //LOCATION( 65, noise/shaders/classicnoise3D.glsl)
>  g001 *= norm1.x;                                                   //LOCATION( 66, noise/shaders/classicnoise3D.glsl)
>  g011 *= norm1.y;                                                   //LOCATION( 67, noise/shaders/classicnoise3D.glsl)
>  g101 *= norm1.z;                                                   //LOCATION( 68, noise/shaders/classicnoise3D.glsl)
>  g111 *= norm1.w;                                                   //LOCATION( 69, noise/shaders/classicnoise3D.glsl)
>                                                                     //LOCATION( 70, noise/shaders/classicnoise3D.glsl)
>  float n000 = dot(g000, Pf0);                                       //LOCATION( 71, noise/shaders/classicnoise3D.glsl)
>  float n100 = dot(g100, vec3(Pf1.x, Pf0.yz));                       //LOCATION( 72, noise/shaders/classicnoise3D.glsl)
>  float n010 = dot(g010, vec3(Pf0.x, Pf1.y, Pf0.z));                 //LOCATION( 73, noise/shaders/classicnoise3D.glsl)
>  float n110 = dot(g110, vec3(Pf1.xy, Pf0.z));                       //LOCATION( 74, noise/shaders/classicnoise3D.glsl)
>  float n001 = dot(g001, vec3(Pf0.xy, Pf1.z));                       //LOCATION( 75, noise/shaders/classicnoise3D.glsl)
>  float n101 = dot(g101, vec3(Pf1.x, Pf0.y, Pf1.z));                 //LOCATION( 76, noise/shaders/classicnoise3D.glsl)
>  float n011 = dot(g011, vec3(Pf0.x, Pf1.yz));                       //LOCATION( 77, noise/shaders/classicnoise3D.glsl)
>  float n111 = dot(g111, Pf1);                                       //LOCATION( 78, noise/shaders/classicnoise3D.glsl)
>                                                                     //LOCATION( 79, noise/shaders/classicnoise3D.glsl)
>  vec3 fade_xyz = fade(Pf0);                                         //LOCATION( 80, noise/shaders/classicnoise3D.glsl)
>  vec4 n_z = mix(vec4(n000, n100, n010, n110), vec4(n001, n101, n011, n111), fade_xyz.z);  //LOCATION( 81, noise/shaders/classicnoise3D.glsl)
>  vec2 n_yz = mix(n_z.xy, n_z.zw, fade_xyz.y);                       //LOCATION( 82, noise/shaders/classicnoise3D.glsl)
>  float n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x);                     //LOCATION( 83, noise/shaders/classicnoise3D.glsl)
>  return 2.2 * n_xyz;                                                //LOCATION( 84, noise/shaders/classicnoise3D.glsl)
>}                                                                    //LOCATION( 85, noise/shaders/classicnoise3D.glsl)
>                                                                     //LOCATION( 86, noise/shaders/classicnoise3D.glsl)
>// Classic Perlin noise, periodic variant                            //LOCATION( 87, noise/shaders/classicnoise3D.glsl)
>float pnoise(vec3 P, vec3 rep)                                       //LOCATION( 88, noise/shaders/classicnoise3D.glsl)
>{                                                                    //LOCATION( 89, noise/shaders/classicnoise3D.glsl)
>  vec3 Pi0 = mod(floor(P), rep); // Integer part, modulo period      //LOCATION( 90, noise/shaders/classicnoise3D.glsl)
>  vec3 Pi1 = mod(Pi0 + vec3(1.0), rep); // Integer part + 1, mod period  //LOCATION( 91, noise/shaders/classicnoise3D.glsl)
>  Pi0 = mod289(Pi0);                                                 //LOCATION( 92, noise/shaders/classicnoise3D.glsl)
>  Pi1 = mod289(Pi1);                                                 //LOCATION( 93, noise/shaders/classicnoise3D.glsl)
>  vec3 Pf0 = fract(P); // Fractional part for interpolation          //LOCATION( 94, noise/shaders/classicnoise3D.glsl)
>  vec3 Pf1 = Pf0 - vec3(1.0); // Fractional part - 1.0               //LOCATION( 95, noise/shaders/classicnoise3D.glsl)
>  vec4 ix = vec4(Pi0.x, Pi1.x, Pi0.x, Pi1.x);                        //LOCATION( 96, noise/shaders/classicnoise3D.glsl)
>  vec4 iy = vec4(Pi0.yy, Pi1.yy);                                    //LOCATION( 97, noise/shaders/classicnoise3D.glsl)
>  vec4 iz0 = Pi0.zzzz;                                               //LOCATION( 98, noise/shaders/classicnoise3D.glsl)
>  vec4 iz1 = Pi1.zzzz;                                               //LOCATION( 99, noise/shaders/classicnoise3D.glsl)
>                                                                     //LOCATION(100, noise/shaders/classicnoise3D.glsl)
>  vec4 ixy = permute(permute(ix) + iy);                              //LOCATION(101, noise/shaders/classicnoise3D.glsl)
>  vec4 ixy0 = permute(ixy + iz0);                                    //LOCATION(102, noise/shaders/classicnoise3D.glsl)
>  vec4 ixy1 = permute(ixy + iz1);                                    //LOCATION(103, noise/shaders/classicnoise3D.glsl)
>                                                                     //LOCATION(104, noise/shaders/classicnoise3D.glsl)
>  vec4 gx0 = ixy0 * (1.0 / 7.0);                                     //LOCATION(105, noise/shaders/classicnoise3D.glsl)
>  vec4 gy0 = fract(floor(gx0) * (1.0 / 7.0)) - 0.5;                  //LOCATION(106, noise/shaders/classicnoise3D.glsl)
>  gx0 = fract(gx0);                                                  //LOCATION(107, noise/shaders/classicnoise3D.glsl)
>  vec4 gz0 = vec4(0.5) - abs(gx0) - abs(gy0);                        //LOCATION(108, noise/shaders/classicnoise3D.glsl)
>  vec4 sz0 = step(gz0, vec4(0.0));                                   //LOCATION(109, noise/shaders/classicnoise3D.glsl)
>  gx0 -= sz0 * (step(0.0, gx0) - 0.5);                               //LOCATION(110, noise/shaders/classicnoise3D.glsl)
>  gy0 -= sz0 * (step(0.0, gy0) - 0.5);                               //LOCATION(111, noise/shaders/classicnoise3D.glsl)
>                                                                     //LOCATION(112, noise/shaders/classicnoise3D.glsl)
>  vec4 gx1 = ixy1 * (1.0 / 7.0);                                     //LOCATION(113, noise/shaders/classicnoise3D.glsl)
>  vec4 gy1 = fract(floor(gx1) * (1.0 / 7.0)) - 0.5;                  //LOCATION(114, noise/shaders/classicnoise3D.glsl)
>  gx1 = fract(gx1);                                                  //LOCATION(115, noise/shaders/classicnoise3D.glsl)
>  vec4 gz1 = vec4(0.5) - abs(gx1) - abs(gy1);                        //LOCATION(116, noise/shaders/classicnoise3D.glsl)
>  vec4 sz1 = step(gz1, vec4(0.0));                                   //LOCATION(117, noise/shaders/classicnoise3D.glsl)
>  gx1 -= sz1 * (step(0.0, gx1) - 0.5);                               //LOCATION(118, noise/shaders/classicnoise3D.glsl)
>  gy1 -= sz1 * (step(0.0, gy1) - 0.5);                               //LOCATION(119, noise/shaders/classicnoise3D.glsl)
>                                                                     //LOCATION(120, noise/shaders/classicnoise3D.glsl)
>  vec3 g000 = vec3(gx0.x,gy0.x,gz0.x);                               //LOCATION(121, noise/shaders/classicnoise3D.glsl)
>  vec3 g100 = vec3(gx0.y,gy0.y,gz0.y);                               //LOCATION(122, noise/shaders/classicnoise3D.glsl)
>  vec3 g010 = vec3(gx0.z,gy0.z,gz0.z);                               //LOCATION(123, noise/shaders/classicnoise3D.glsl)
>  vec3 g110 = vec3(gx0.w,gy0.w,gz0.w);                               //LOCATION(124, noise/shaders/classicnoise3D.glsl)
>  vec3 g001 = vec3(gx1.x,gy1.x,gz1.x);                               //LOCATION(125, noise/shaders/classicnoise3D.glsl)
>  vec3 g101 = vec3(gx1.y,gy1.y,gz1.y);                               //LOCATION(126, noise/shaders/classicnoise3D.glsl)
>  vec3 g011 = vec3(gx1.z,gy1.z,gz1.z);                               //LOCATION(127, noise/shaders/classicnoise3D.glsl)
>  vec3 g111 = vec3(gx1.w,gy1.w,gz1.w);                               //LOCATION(128, noise/shaders/classicnoise3D.glsl)
>                                                                     //LOCATION(129, noise/shaders/classicnoise3D.glsl)
>  vec4 norm0 = taylorInvSqrt(vec4(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));  //LOCATION(130, noise/shaders/classicnoise3D.glsl)
>  g000 *= norm0.x;                                                   //LOCATION(131, noise/shaders/classicnoise3D.glsl)
>  g010 *= norm0.y;                                                   //LOCATION(132, noise/shaders/classicnoise3D.glsl)
>  g100 *= norm0.z;                                                   //LOCATION(133, noise/shaders/classicnoise3D.glsl)
>  g110 *= norm0.w;                                                   //LOCATION(134, noise/shaders/classicnoise3D.glsl)
>  vec4 norm1 = taylorInvSqrt(vec4(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));  //LOCATION(135, noise/shaders/classicnoise3D.glsl)
>  g001 *= norm1.x;                                                   //LOCATION(136, noise/shaders/classicnoise3D.glsl)
>  g011 *= norm1.y;                                                   //LOCATION(137, noise/shaders/classicnoise3D.glsl)
>  g101 *= norm1.z;                                                   //LOCATION(138, noise/shaders/classicnoise3D.glsl)
>  g111 *= norm1.w;                                                   //LOCATION(139, noise/shaders/classicnoise3D.glsl)
>                                                                     //LOCATION(140, noise/shaders/classicnoise3D.glsl)
>  float n000 = dot(g000, Pf0);                                       //LOCATION(141, noise/shaders/classicnoise3D.glsl)
>  float n100 = dot(g100, vec3(Pf1.x, Pf0.yz));                       //LOCATION(142, noise/shaders/classicnoise3D.glsl)
>  float n010 = dot(g010, vec3(Pf0.x, Pf1.y, Pf0.z));                 //LOCATION(143, noise/shaders/classicnoise3D.glsl)
>  float n110 = dot(g110, vec3(Pf1.xy, Pf0.z));                       //LOCATION(144, noise/shaders/classicnoise3D.glsl)
>  float n001 = dot(g001, vec3(Pf0.xy, Pf1.z));                       //LOCATION(145, noise/shaders/classicnoise3D.glsl)
>  float n101 = dot(g101, vec3(Pf1.x, Pf0.y, Pf1.z));                 //LOCATION(146, noise/shaders/classicnoise3D.glsl)
>  float n011 = dot(g011, vec3(Pf0.x, Pf1.yz));                       //LOCATION(147, noise/shaders/classicnoise3D.glsl)
>  float n111 = dot(g111, Pf1);                                       //LOCATION(148, noise/shaders/classicnoise3D.glsl)
>                                                                     //LOCATION(149, noise/shaders/classicnoise3D.glsl)
>  vec3 fade_xyz = fade(Pf0);                                         //LOCATION(150, noise/shaders/classicnoise3D.glsl)
>  vec4 n_z = mix(vec4(n000, n100, n010, n110), vec4(n001, n101, n011, n111), fade_xyz.z);  //LOCATION(151, noise/shaders/classicnoise3D.glsl)
>  vec2 n_yz = mix(n_z.xy, n_z.zw, fade_xyz.y);                       //LOCATION(152, noise/shaders/classicnoise3D.glsl)
>  float n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x);                     //LOCATION(153, noise/shaders/classicnoise3D.glsl)
>  return 2.2 * n_xyz;                                                //LOCATION(154, noise/shaders/classicnoise3D.glsl)
>}                                                                    //LOCATION(155, noise/shaders/classicnoise3D.glsl)
>//                                                                   //LOCATION(  1, noise/shaders/noise3D.glsl)
>// Description : Array and textureless GLSL 2D/3D/4D simplex         //LOCATION(  2, noise/shaders/noise3D.glsl)
>//               noise functions.                                    //LOCATION(  3, noise/shaders/noise3D.glsl)
>//      Author : Ian McEwan, Ashima Arts.                            //LOCATION(  4, noise/shaders/noise3D.glsl)
>//  Maintainer : ijm                                                 //LOCATION(  5, noise/shaders/noise3D.glsl)
>//     Lastmod : 20110822 (ijm)                                      //LOCATION(  6, noise/shaders/noise3D.glsl)
>//     License : Copyright (C) 2011 Ashima Arts. All rights reserved.  //LOCATION(  7, noise/shaders/noise3D.glsl)
>//               Distributed under the MIT License. See LICENSE file.  //LOCATION(  8, noise/shaders/noise3D.glsl)
>//               https://github.com/ashima/webgl-noise               //LOCATION(  9, noise/shaders/noise3D.glsl)
>//                                                                   //LOCATION( 10, noise/shaders/noise3D.glsl)
>                                                                     //LOCATION( 11, noise/shaders/noise3D.glsl)
>                                                                     //LOCATION( 12, noise/shaders/noise3D.glsl)
>                                                                     //LOCATION( 13, noise/shaders/noise3D.glsl)
>float snoise(vec3 v)                                                 //LOCATION( 14, noise/shaders/noise3D.glsl)
>  {                                                                  //LOCATION( 15, noise/shaders/noise3D.glsl)
>  const vec2  C = vec2(1.0/6.0, 1.0/3.0) ;                           //LOCATION( 16, noise/shaders/noise3D.glsl)
>  const vec4  D = vec4(0.0, 0.5, 1.0, 2.0);                          //LOCATION( 17, noise/shaders/noise3D.glsl)
>                                                                     //LOCATION( 18, noise/shaders/noise3D.glsl)
>// First corner                                                      //LOCATION( 19, noise/shaders/noise3D.glsl)
>  vec3 i  = floor(v + dot(v, C.yyy) );                               //LOCATION( 20, noise/shaders/noise3D.glsl)
>  vec3 x0 =   v - i + dot(i, C.xxx) ;                                //LOCATION( 21, noise/shaders/noise3D.glsl)
>                                                                     //LOCATION( 22, noise/shaders/noise3D.glsl)
>// Other corners                                                     //LOCATION( 23, noise/shaders/noise3D.glsl)
>  vec3 g = step(x0.yzx, x0.xyz);                                     //LOCATION( 24, noise/shaders/noise3D.glsl)
>  vec3 l = 1.0 - g;                                                  //LOCATION( 25, noise/shaders/noise3D.glsl)
>  vec3 i1 = min( g.xyz, l.zxy );                                     //LOCATION( 26, noise/shaders/noise3D.glsl)
>  vec3 i2 = max( g.xyz, l.zxy );                                     //LOCATION( 27, noise/shaders/noise3D.glsl)
>                                                                     //LOCATION( 28, noise/shaders/noise3D.glsl)
>  //   x0 = x0 - 0.0 + 0.0 * C.xxx;                                  //LOCATION( 29, noise/shaders/noise3D.glsl)
>  //   x1 = x0 - i1  + 1.0 * C.xxx;                                  //LOCATION( 30, noise/shaders/noise3D.glsl)
>  //   x2 = x0 - i2  + 2.0 * C.xxx;                                  //LOCATION( 31, noise/shaders/noise3D.glsl)
>  //   x3 = x0 - 1.0 + 3.0 * C.xxx;                                  //LOCATION( 32, noise/shaders/noise3D.glsl)
>  vec3 x1 = x0 - i1 + C.xxx;                                         //LOCATION( 33, noise/shaders/noise3D.glsl)
>  vec3 x2 = x0 - i2 + C.yyy; // 2.0*C.x = 1/3 = C.y                  //LOCATION( 34, noise/shaders/noise3D.glsl)
>  vec3 x3 = x0 - D.yyy;      // -1.0+3.0*C.x = -0.5 = -D.y           //LOCATION( 35, noise/shaders/noise3D.glsl)
>                                                                     //LOCATION( 36, noise/shaders/noise3D.glsl)
>// Permutations                                                      //LOCATION( 37, noise/shaders/noise3D.glsl)
>  i = mod289(i);                                                     //LOCATION( 38, noise/shaders/noise3D.glsl)
>  vec4 p = permute( permute( permute(                                //LOCATION( 39, noise/shaders/noise3D.glsl)
>             i.z + vec4(0.0, i1.z, i2.z, 1.0 ))                      //LOCATION( 40, noise/shaders/noise3D.glsl)
>           + i.y + vec4(0.0, i1.y, i2.y, 1.0 ))                      //LOCATION( 41, noise/shaders/noise3D.glsl)
>           + i.x + vec4(0.0, i1.x, i2.x, 1.0 ));                     //LOCATION( 42, noise/shaders/noise3D.glsl)
>                                                                     //LOCATION( 43, noise/shaders/noise3D.glsl)
>// Gradients: 7x7 points over a square, mapped onto an octahedron.   //LOCATION( 44, noise/shaders/noise3D.glsl)
>// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)  //LOCATION( 45, noise/shaders/noise3D.glsl)
>  float n_ = 0.142857142857; // 1.0/7.0                              //LOCATION( 46, noise/shaders/noise3D.glsl)
>  vec3  ns = n_ * D.wyz - D.xzx;                                     //LOCATION( 47, noise/shaders/noise3D.glsl)
>                                                                     //LOCATION( 48, noise/shaders/noise3D.glsl)
>  vec4 j = p - 49.0 * floor(p * ns.z * ns.z);  //  mod(p,7*7)        //LOCATION( 49, noise/shaders/noise3D.glsl)
>                                                                     //LOCATION( 50, noise/shaders/noise3D.glsl)
>  vec4 x_ = floor(j * ns.z);                                         //LOCATION( 51, noise/shaders/noise3D.glsl)
>  vec4 y_ = floor(j - 7.0 * x_ );    // mod(j,N)                     //LOCATION( 52, noise/shaders/noise3D.glsl)
>                                                                     //LOCATION( 53, noise/shaders/noise3D.glsl)
>  vec4 x = x_ *ns.x + ns.yyyy;                                       //LOCATION( 54, noise/shaders/noise3D.glsl)
>  vec4 y = y_ *ns.x + ns.yyyy;                                       //LOCATION( 55, noise/shaders/noise3D.glsl)
>  vec4 h = 1.0 - abs(x) - abs(y);                                    //LOCATION( 56, noise/shaders/noise3D.glsl)
>                                                                     //LOCATION( 57, noise/shaders/noise3D.glsl)
>  vec4 b0 = vec4( x.xy, y.xy );                                      //LOCATION( 58, noise/shaders/noise3D.glsl)
>  vec4 b1 = vec4( x.zw, y.zw );                                      //LOCATION( 59, noise/shaders/noise3D.glsl)
>                                                                     //LOCATION( 60, noise/shaders/noise3D.glsl)
>  //vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;                      //LOCATION( 61, noise/shaders/noise3D.glsl)
>  //vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;                      //LOCATION( 62, noise/shaders/noise3D.glsl)
>  vec4 s0 = floor(b0)*2.0 + 1.0;                                     //LOCATION( 63, noise/shaders/noise3D.glsl)
>  vec4 s1 = floor(b1)*2.0 + 1.0;                                     //LOCATION( 64, noise/shaders/noise3D.glsl)
>  vec4 sh = -step(h, vec4(0.0));                                     //LOCATION( 65, noise/shaders/noise3D.glsl)
>                                                                     //LOCATION( 66, noise/shaders/noise3D.glsl)
>  vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ;                              //LOCATION( 67, noise/shaders/noise3D.glsl)
>  vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww ;                              //LOCATION( 68, noise/shaders/noise3D.glsl)
>                                                                     //LOCATION( 69, noise/shaders/noise3D.glsl)
>  vec3 p0 = vec3(a0.xy,h.x);                                         //LOCATION( 70, noise/shaders/noise3D.glsl)
>  vec3 p1 = vec3(a0.zw,h.y);                                         //LOCATION( 71, noise/shaders/noise3D.glsl)
>  vec3 p2 = vec3(a1.xy,h.z);                                         //LOCATION( 72, noise/shaders/noise3D.glsl)
>  vec3 p3 = vec3(a1.zw,h.w);                                         //LOCATION( 73, noise/shaders/noise3D.glsl)
>                                                                     //LOCATION( 74, noise/shaders/noise3D.glsl)
>//Normalise gradients                                                //LOCATION( 75, noise/shaders/noise3D.glsl)
>  vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));  //LOCATION( 76, noise/shaders/noise3D.glsl)
>  p0 *= norm.x;                                                      //LOCATION( 77, noise/shaders/noise3D.glsl)
>  p1 *= norm.y;                                                      //LOCATION( 78, noise/shaders/noise3D.glsl)
>  p2 *= norm.z;                                                      //LOCATION( 79, noise/shaders/noise3D.glsl)
>  p3 *= norm.w;                                                      //LOCATION( 80, noise/shaders/noise3D.glsl)
>                                                                     //LOCATION( 81, noise/shaders/noise3D.glsl)
>// Mix final noise value                                             //LOCATION( 82, noise/shaders/noise3D.glsl)
>  vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0);  //LOCATION( 83, noise/shaders/noise3D.glsl)
>  m = m * m;                                                         //LOCATION( 84, noise/shaders/noise3D.glsl)
>  return 42.0 * dot( m*m, vec4( dot(p0,x0), dot(p1,x1),              //LOCATION( 85, noise/shaders/noise3D.glsl)
>                                dot(p2,x2), dot(p3,x3) ) );          //LOCATION( 86, noise/shaders/noise3D.glsl)
>  }                                                                  //LOCATION( 87, noise/shaders/noise3D.glsl)
>//                                                                   //LOCATION(  1, noise/shaders/classicnoise4D.glsl)
>// GLSL textureless classic 4D noise "cnoise",                       //LOCATION(  2, noise/shaders/classicnoise4D.glsl)
>// with an RSL-style periodic variant "pnoise".                      //LOCATION(  3, noise/shaders/classicnoise4D.glsl)
>// Author:  Stefan Gustavson (stefan.gustavson@liu.se)               //LOCATION(  4, noise/shaders/classicnoise4D.glsl)
>// Version: 2011-08-22                                               //LOCATION(  5, noise/shaders/classicnoise4D.glsl)
>//                                                                   //LOCATION(  6, noise/shaders/classicnoise4D.glsl)
>// Many thanks to Ian McEwan of Ashima Arts for the                  //LOCATION(  7, noise/shaders/classicnoise4D.glsl)
>// ideas for permutation and gradient selection.                     //LOCATION(  8, noise/shaders/classicnoise4D.glsl)
>//                                                                   //LOCATION(  9, noise/shaders/classicnoise4D.glsl)
>// Copyright (c) 2011 Stefan Gustavson. All rights reserved.         //LOCATION( 10, noise/shaders/classicnoise4D.glsl)
>// Distributed under the MIT license. See LICENSE file.              //LOCATION( 11, noise/shaders/classicnoise4D.glsl)
>// https://github.com/ashima/webgl-noise                             //LOCATION( 12, noise/shaders/classicnoise4D.glsl)
>//                                                                   //LOCATION( 13, noise/shaders/classicnoise4D.glsl)
>                                                                     //LOCATION( 14, noise/shaders/classicnoise4D.glsl)
>                                                                     //LOCATION( 15, noise/shaders/classicnoise4D.glsl)
>                                                                     //LOCATION( 16, noise/shaders/classicnoise4D.glsl)
>// Classic Perlin noise                                              //LOCATION( 17, noise/shaders/classicnoise4D.glsl)
>float cnoise(vec4 P)                                                 //LOCATION( 18, noise/shaders/classicnoise4D.glsl)
>{                                                                    //LOCATION( 19, noise/shaders/classicnoise4D.glsl)
>  vec4 Pi0 = floor(P); // Integer part for indexing                  //LOCATION( 20, noise/shaders/classicnoise4D.glsl)
>  vec4 Pi1 = Pi0 + 1.0; // Integer part + 1                          //LOCATION( 21, noise/shaders/classicnoise4D.glsl)
>  Pi0 = mod289(Pi0);                                                 //LOCATION( 22, noise/shaders/classicnoise4D.glsl)
>  Pi1 = mod289(Pi1);                                                 //LOCATION( 23, noise/shaders/classicnoise4D.glsl)
>  vec4 Pf0 = fract(P); // Fractional part for interpolation          //LOCATION( 24, noise/shaders/classicnoise4D.glsl)
>  vec4 Pf1 = Pf0 - 1.0; // Fractional part - 1.0                     //LOCATION( 25, noise/shaders/classicnoise4D.glsl)
>  vec4 ix = vec4(Pi0.x, Pi1.x, Pi0.x, Pi1.x);                        //LOCATION( 26, noise/shaders/classicnoise4D.glsl)
>  vec4 iy = vec4(Pi0.yy, Pi1.yy);                                    //LOCATION( 27, noise/shaders/classicnoise4D.glsl)
>  vec4 iz0 = vec4(Pi0.zzzz);                                         //LOCATION( 28, noise/shaders/classicnoise4D.glsl)
>  vec4 iz1 = vec4(Pi1.zzzz);                                         //LOCATION( 29, noise/shaders/classicnoise4D.glsl)
>  vec4 iw0 = vec4(Pi0.wwww);                                         //LOCATION( 30, noise/shaders/classicnoise4D.glsl)
>  vec4 iw1 = vec4(Pi1.wwww);                                         //LOCATION( 31, noise/shaders/classicnoise4D.glsl)
>                                                                     //LOCATION( 32, noise/shaders/classicnoise4D.glsl)
>  vec4 ixy = permute(permute(ix) + iy);                              //LOCATION( 33, noise/shaders/classicnoise4D.glsl)
>  vec4 ixy0 = permute(ixy + iz0);                                    //LOCATION( 34, noise/shaders/classicnoise4D.glsl)
>  vec4 ixy1 = permute(ixy + iz1);                                    //LOCATION( 35, noise/shaders/classicnoise4D.glsl)
>  vec4 ixy00 = permute(ixy0 + iw0);                                  //LOCATION( 36, noise/shaders/classicnoise4D.glsl)
>  vec4 ixy01 = permute(ixy0 + iw1);                                  //LOCATION( 37, noise/shaders/classicnoise4D.glsl)
>  vec4 ixy10 = permute(ixy1 + iw0);                                  //LOCATION( 38, noise/shaders/classicnoise4D.glsl)
>  vec4 ixy11 = permute(ixy1 + iw1);                                  //LOCATION( 39, noise/shaders/classicnoise4D.glsl)
>                                                                     //LOCATION( 40, noise/shaders/classicnoise4D.glsl)
>  vec4 gx00 = ixy00 * (1.0 / 7.0);                                   //LOCATION( 41, noise/shaders/classicnoise4D.glsl)
>  vec4 gy00 = floor(gx00) * (1.0 / 7.0);                             //LOCATION( 42, noise/shaders/classicnoise4D.glsl)
>  vec4 gz00 = floor(gy00) * (1.0 / 6.0);                             //LOCATION( 43, noise/shaders/classicnoise4D.glsl)
>  gx00 = fract(gx00) - 0.5;                                          //LOCATION( 44, noise/shaders/classicnoise4D.glsl)
>  gy00 = fract(gy00) - 0.5;                                          //LOCATION( 45, noise/shaders/classicnoise4D.glsl)
>  gz00 = fract(gz00) - 0.5;                                          //LOCATION( 46, noise/shaders/classicnoise4D.glsl)
>  vec4 gw00 = vec4(0.75) - abs(gx00) - abs(gy00) - abs(gz00);        //LOCATION( 47, noise/shaders/classicnoise4D.glsl)
>  vec4 sw00 = step(gw00, vec4(0.0));                                 //LOCATION( 48, noise/shaders/classicnoise4D.glsl)
>  gx00 -= sw00 * (step(0.0, gx00) - 0.5);                            //LOCATION( 49, noise/shaders/classicnoise4D.glsl)
>  gy00 -= sw00 * (step(0.0, gy00) - 0.5);                            //LOCATION( 50, noise/shaders/classicnoise4D.glsl)
>                                                                     //LOCATION( 51, noise/shaders/classicnoise4D.glsl)
>  vec4 gx01 = ixy01 * (1.0 / 7.0);                                   //LOCATION( 52, noise/shaders/classicnoise4D.glsl)
>  vec4 gy01 = floor(gx01) * (1.0 / 7.0);                             //LOCATION( 53, noise/shaders/classicnoise4D.glsl)
>  vec4 gz01 = floor(gy01) * (1.0 / 6.0);                             //LOCATION( 54, noise/shaders/classicnoise4D.glsl)
>  gx01 = fract(gx01) - 0.5;                                          //LOCATION( 55, noise/shaders/classicnoise4D.glsl)
>  gy01 = fract(gy01) - 0.5;                                          //LOCATION( 56, noise/shaders/classicnoise4D.glsl)
>  gz01 = fract(gz01) - 0.5;                                          //LOCATION( 57, noise/shaders/classicnoise4D.glsl)
>  vec4 gw01 = vec4(0.75) - abs(gx01) - abs(gy01) - abs(gz01);        //LOCATION( 58, noise/shaders/classicnoise4D.glsl)
>  vec4 sw01 = step(gw01, vec4(0.0));                                 //LOCATION( 59, noise/shaders/classicnoise4D.glsl)
>  gx01 -= sw01 * (step(0.0, gx01) - 0.5);                            //LOCATION( 60, noise/shaders/classicnoise4D.glsl)
>  gy01 -= sw01 * (step(0.0, gy01) - 0.5);                            //LOCATION( 61, noise/shaders/classicnoise4D.glsl)
>                                                                     //LOCATION( 62, noise/shaders/classicnoise4D.glsl)
>  vec4 gx10 = ixy10 * (1.0 / 7.0);                                   //LOCATION( 63, noise/shaders/classicnoise4D.glsl)
>  vec4 gy10 = floor(gx10) * (1.0 / 7.0);                             //LOCATION( 64, noise/shaders/classicnoise4D.glsl)
>  vec4 gz10 = floor(gy10) * (1.0 / 6.0);                             //LOCATION( 65, noise/shaders/classicnoise4D.glsl)
>  gx10 = fract(gx10) - 0.5;                                          //LOCATION( 66, noise/shaders/classicnoise4D.glsl)
>  gy10 = fract(gy10) - 0.5;                                          //LOCATION( 67, noise/shaders/classicnoise4D.glsl)
>  gz10 = fract(gz10) - 0.5;                                          //LOCATION( 68, noise/shaders/classicnoise4D.glsl)
>  vec4 gw10 = vec4(0.75) - abs(gx10) - abs(gy10) - abs(gz10);        //LOCATION( 69, noise/shaders/classicnoise4D.glsl)
>  vec4 sw10 = step(gw10, vec4(0.0));                                 //LOCATION( 70, noise/shaders/classicnoise4D.glsl)
>  gx10 -= sw10 * (step(0.0, gx10) - 0.5);                            //LOCATION( 71, noise/shaders/classicnoise4D.glsl)
>  gy10 -= sw10 * (step(0.0, gy10) - 0.5);                            //LOCATION( 72, noise/shaders/classicnoise4D.glsl)
>                                                                     //LOCATION( 73, noise/shaders/classicnoise4D.glsl)
>  vec4 gx11 = ixy11 * (1.0 / 7.0);                                   //LOCATION( 74, noise/shaders/classicnoise4D.glsl)
>  vec4 gy11 = floor(gx11) * (1.0 / 7.0);                             //LOCATION( 75, noise/shaders/classicnoise4D.glsl)
>  vec4 gz11 = floor(gy11) * (1.0 / 6.0);                             //LOCATION( 76, noise/shaders/classicnoise4D.glsl)
>  gx11 = fract(gx11) - 0.5;                                          //LOCATION( 77, noise/shaders/classicnoise4D.glsl)
>  gy11 = fract(gy11) - 0.5;                                          //LOCATION( 78, noise/shaders/classicnoise4D.glsl)
>  gz11 = fract(gz11) - 0.5;                                          //LOCATION( 79, noise/shaders/classicnoise4D.glsl)
>  vec4 gw11 = vec4(0.75) - abs(gx11) - abs(gy11) - abs(gz11);        //LOCATION( 80, noise/shaders/classicnoise4D.glsl)
>  vec4 sw11 = step(gw11, vec4(0.0));                                 //LOCATION( 81, noise/shaders/classicnoise4D.glsl)
>  gx11 -= sw11 * (step(0.0, gx11) - 0.5);                            //LOCATION( 82, noise/shaders/classicnoise4D.glsl)
>  gy11 -= sw11 * (step(0.0, gy11) - 0.5);                            //LOCATION( 83, noise/shaders/classicnoise4D.glsl)
>                                                                     //LOCATION( 84, noise/shaders/classicnoise4D.glsl)
>  vec4 g0000 = vec4(gx00.x,gy00.x,gz00.x,gw00.x);                    //LOCATION( 85, noise/shaders/classicnoise4D.glsl)
>  vec4 g1000 = vec4(gx00.y,gy00.y,gz00.y,gw00.y);                    //LOCATION( 86, noise/shaders/classicnoise4D.glsl)
>  vec4 g0100 = vec4(gx00.z,gy00.z,gz00.z,gw00.z);                    //LOCATION( 87, noise/shaders/classicnoise4D.glsl)
>  vec4 g1100 = vec4(gx00.w,gy00.w,gz00.w,gw00.w);                    //LOCATION( 88, noise/shaders/classicnoise4D.glsl)
>  vec4 g0010 = vec4(gx10.x,gy10.x,gz10.x,gw10.x);                    //LOCATION( 89, noise/shaders/classicnoise4D.glsl)
>  vec4 g1010 = vec4(gx10.y,gy10.y,gz10.y,gw10.y);                    //LOCATION( 90, noise/shaders/classicnoise4D.glsl)
>  vec4 g0110 = vec4(gx10.z,gy10.z,gz10.z,gw10.z);                    //LOCATION( 91, noise/shaders/classicnoise4D.glsl)
>  vec4 g1110 = vec4(gx10.w,gy10.w,gz10.w,gw10.w);                    //LOCATION( 92, noise/shaders/classicnoise4D.glsl)
>  vec4 g0001 = vec4(gx01.x,gy01.x,gz01.x,gw01.x);                    //LOCATION( 93, noise/shaders/classicnoise4D.glsl)
>  vec4 g1001 = vec4(gx01.y,gy01.y,gz01.y,gw01.y);                    //LOCATION( 94, noise/shaders/classicnoise4D.glsl)
>  vec4 g0101 = vec4(gx01.z,gy01.z,gz01.z,gw01.z);                    //LOCATION( 95, noise/shaders/classicnoise4D.glsl)
>  vec4 g1101 = vec4(gx01.w,gy01.w,gz01.w,gw01.w);                    //LOCATION( 96, noise/shaders/classicnoise4D.glsl)
>  vec4 g0011 = vec4(gx11.x,gy11.x,gz11.x,gw11.x);                    //LOCATION( 97, noise/shaders/classicnoise4D.glsl)
>  vec4 g1011 = vec4(gx11.y,gy11.y,gz11.y,gw11.y);                    //LOCATION( 98, noise/shaders/classicnoise4D.glsl)
>  vec4 g0111 = vec4(gx11.z,gy11.z,gz11.z,gw11.z);                    //LOCATION( 99, noise/shaders/classicnoise4D.glsl)
>  vec4 g1111 = vec4(gx11.w,gy11.w,gz11.w,gw11.w);                    //LOCATION(100, noise/shaders/classicnoise4D.glsl)
>                                                                     //LOCATION(101, noise/shaders/classicnoise4D.glsl)
>  vec4 norm00 = taylorInvSqrt(vec4(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100)));  //LOCATION(102, noise/shaders/classicnoise4D.glsl)
>  g0000 *= norm00.x;                                                 //LOCATION(103, noise/shaders/classicnoise4D.glsl)
>  g0100 *= norm00.y;                                                 //LOCATION(104, noise/shaders/classicnoise4D.glsl)
>  g1000 *= norm00.z;                                                 //LOCATION(105, noise/shaders/classicnoise4D.glsl)
>  g1100 *= norm00.w;                                                 //LOCATION(106, noise/shaders/classicnoise4D.glsl)
>                                                                     //LOCATION(107, noise/shaders/classicnoise4D.glsl)
>  vec4 norm01 = taylorInvSqrt(vec4(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101)));  //LOCATION(108, noise/shaders/classicnoise4D.glsl)
>  g0001 *= norm01.x;                                                 //LOCATION(109, noise/shaders/classicnoise4D.glsl)
>  g0101 *= norm01.y;                                                 //LOCATION(110, noise/shaders/classicnoise4D.glsl)
>  g1001 *= norm01.z;                                                 //LOCATION(111, noise/shaders/classicnoise4D.glsl)
>  g1101 *= norm01.w;                                                 //LOCATION(112, noise/shaders/classicnoise4D.glsl)
>                                                                     //LOCATION(113, noise/shaders/classicnoise4D.glsl)
>  vec4 norm10 = taylorInvSqrt(vec4(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110)));  //LOCATION(114, noise/shaders/classicnoise4D.glsl)
>  g0010 *= norm10.x;                                                 //LOCATION(115, noise/shaders/classicnoise4D.glsl)
>  g0110 *= norm10.y;                                                 //LOCATION(116, noise/shaders/classicnoise4D.glsl)
>  g1010 *= norm10.z;                                                 //LOCATION(117, noise/shaders/classicnoise4D.glsl)
>  g1110 *= norm10.w;                                                 //LOCATION(118, noise/shaders/classicnoise4D.glsl)
>                                                                     //LOCATION(119, noise/shaders/classicnoise4D.glsl)
>  vec4 norm11 = taylorInvSqrt(vec4(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111)));  //LOCATION(120, noise/shaders/classicnoise4D.glsl)
>  g0011 *= norm11.x;                                                 //LOCATION(121, noise/shaders/classicnoise4D.glsl)
>  g0111 *= norm11.y;                                                 //LOCATION(122, noise/shaders/classicnoise4D.glsl)
>  g1011 *= norm11.z;                                                 //LOCATION(123, noise/shaders/classicnoise4D.glsl)
>  g1111 *= norm11.w;                                                 //LOCATION(124, noise/shaders/classicnoise4D.glsl)
>                                                                     //LOCATION(125, noise/shaders/classicnoise4D.glsl)
>  float n0000 = dot(g0000, Pf0);                                     //LOCATION(126, noise/shaders/classicnoise4D.glsl)
>  float n1000 = dot(g1000, vec4(Pf1.x, Pf0.yzw));                    //LOCATION(127, noise/shaders/classicnoise4D.glsl)
>  float n0100 = dot(g0100, vec4(Pf0.x, Pf1.y, Pf0.zw));              //LOCATION(128, noise/shaders/classicnoise4D.glsl)
>  float n1100 = dot(g1100, vec4(Pf1.xy, Pf0.zw));                    //LOCATION(129, noise/shaders/classicnoise4D.glsl)
>  float n0010 = dot(g0010, vec4(Pf0.xy, Pf1.z, Pf0.w));              //LOCATION(130, noise/shaders/classicnoise4D.glsl)
>  float n1010 = dot(g1010, vec4(Pf1.x, Pf0.y, Pf1.z, Pf0.w));        //LOCATION(131, noise/shaders/classicnoise4D.glsl)
>  float n0110 = dot(g0110, vec4(Pf0.x, Pf1.yz, Pf0.w));              //LOCATION(132, noise/shaders/classicnoise4D.glsl)
>  float n1110 = dot(g1110, vec4(Pf1.xyz, Pf0.w));                    //LOCATION(133, noise/shaders/classicnoise4D.glsl)
>  float n0001 = dot(g0001, vec4(Pf0.xyz, Pf1.w));                    //LOCATION(134, noise/shaders/classicnoise4D.glsl)
>  float n1001 = dot(g1001, vec4(Pf1.x, Pf0.yz, Pf1.w));              //LOCATION(135, noise/shaders/classicnoise4D.glsl)
>  float n0101 = dot(g0101, vec4(Pf0.x, Pf1.y, Pf0.z, Pf1.w));        //LOCATION(136, noise/shaders/classicnoise4D.glsl)
>  float n1101 = dot(g1101, vec4(Pf1.xy, Pf0.z, Pf1.w));              //LOCATION(137, noise/shaders/classicnoise4D.glsl)
>  float n0011 = dot(g0011, vec4(Pf0.xy, Pf1.zw));                    //LOCATION(138, noise/shaders/classicnoise4D.glsl)
>  float n1011 = dot(g1011, vec4(Pf1.x, Pf0.y, Pf1.zw));              //LOCATION(139, noise/shaders/classicnoise4D.glsl)
>  float n0111 = dot(g0111, vec4(Pf0.x, Pf1.yzw));                    //LOCATION(140, noise/shaders/classicnoise4D.glsl)
>  float n1111 = dot(g1111, Pf1);                                     //LOCATION(141, noise/shaders/classicnoise4D.glsl)
>                                                                     //LOCATION(142, noise/shaders/classicnoise4D.glsl)
>  vec4 fade_xyzw = fade(Pf0);                                        //LOCATION(143, noise/shaders/classicnoise4D.glsl)
>  vec4 n_0w = mix(vec4(n0000, n1000, n0100, n1100), vec4(n0001, n1001, n0101, n1101), fade_xyzw.w);  //LOCATION(144, noise/shaders/classicnoise4D.glsl)
>  vec4 n_1w = mix(vec4(n0010, n1010, n0110, n1110), vec4(n0011, n1011, n0111, n1111), fade_xyzw.w);  //LOCATION(145, noise/shaders/classicnoise4D.glsl)
>  vec4 n_zw = mix(n_0w, n_1w, fade_xyzw.z);                          //LOCATION(146, noise/shaders/classicnoise4D.glsl)
>  vec2 n_yzw = mix(n_zw.xy, n_zw.zw, fade_xyzw.y);                   //LOCATION(147, noise/shaders/classicnoise4D.glsl)
>  float n_xyzw = mix(n_yzw.x, n_yzw.y, fade_xyzw.x);                 //LOCATION(148, noise/shaders/classicnoise4D.glsl)
>  return 2.2 * n_xyzw;                                               //LOCATION(149, noise/shaders/classicnoise4D.glsl)
>}                                                                    //LOCATION(150, noise/shaders/classicnoise4D.glsl)
>                                                                     //LOCATION(151, noise/shaders/classicnoise4D.glsl)
>// Classic Perlin noise, periodic version                            //LOCATION(152, noise/shaders/classicnoise4D.glsl)
>float pnoise(vec4 P, vec4 rep)                                       //LOCATION(153, noise/shaders/classicnoise4D.glsl)
>{                                                                    //LOCATION(154, noise/shaders/classicnoise4D.glsl)
>  vec4 Pi0 = mod(floor(P), rep); // Integer part modulo rep          //LOCATION(155, noise/shaders/classicnoise4D.glsl)
>  vec4 Pi1 = mod(Pi0 + 1.0, rep); // Integer part + 1 mod rep        //LOCATION(156, noise/shaders/classicnoise4D.glsl)
>  Pi0 = mod289(Pi0);                                                 //LOCATION(157, noise/shaders/classicnoise4D.glsl)
>  Pi1 = mod289(Pi1);                                                 //LOCATION(158, noise/shaders/classicnoise4D.glsl)
>  vec4 Pf0 = fract(P); // Fractional part for interpolation          //LOCATION(159, noise/shaders/classicnoise4D.glsl)
>  vec4 Pf1 = Pf0 - 1.0; // Fractional part - 1.0                     //LOCATION(160, noise/shaders/classicnoise4D.glsl)
>  vec4 ix = vec4(Pi0.x, Pi1.x, Pi0.x, Pi1.x);                        //LOCATION(161, noise/shaders/classicnoise4D.glsl)
>  vec4 iy = vec4(Pi0.yy, Pi1.yy);                                    //LOCATION(162, noise/shaders/classicnoise4D.glsl)
>  vec4 iz0 = vec4(Pi0.zzzz);                                         //LOCATION(163, noise/shaders/classicnoise4D.glsl)
>  vec4 iz1 = vec4(Pi1.zzzz);                                         //LOCATION(164, noise/shaders/classicnoise4D.glsl)
>  vec4 iw0 = vec4(Pi0.wwww);                                         //LOCATION(165, noise/shaders/classicnoise4D.glsl)
>  vec4 iw1 = vec4(Pi1.wwww);                                         //LOCATION(166, noise/shaders/classicnoise4D.glsl)
>                                                                     //LOCATION(167, noise/shaders/classicnoise4D.glsl)
>  vec4 ixy = permute(permute(ix) + iy);                              //LOCATION(168, noise/shaders/classicnoise4D.glsl)
>  vec4 ixy0 = permute(ixy + iz0);                                    //LOCATION(169, noise/shaders/classicnoise4D.glsl)
>  vec4 ixy1 = permute(ixy + iz1);                                    //LOCATION(170, noise/shaders/classicnoise4D.glsl)
>  vec4 ixy00 = permute(ixy0 + iw0);                                  //LOCATION(171, noise/shaders/classicnoise4D.glsl)
>  vec4 ixy01 = permute(ixy0 + iw1);                                  //LOCATION(172, noise/shaders/classicnoise4D.glsl)
>  vec4 ixy10 = permute(ixy1 + iw0);                                  //LOCATION(173, noise/shaders/classicnoise4D.glsl)
>  vec4 ixy11 = permute(ixy1 + iw1);                                  //LOCATION(174, noise/shaders/classicnoise4D.glsl)
>                                                                     //LOCATION(175, noise/shaders/classicnoise4D.glsl)
>  vec4 gx00 = ixy00 * (1.0 / 7.0);                                   //LOCATION(176, noise/shaders/classicnoise4D.glsl)
>  vec4 gy00 = floor(gx00) * (1.0 / 7.0);                             //LOCATION(177, noise/shaders/classicnoise4D.glsl)
>  vec4 gz00 = floor(gy00) * (1.0 / 6.0);                             //LOCATION(178, noise/shaders/classicnoise4D.glsl)
>  gx00 = fract(gx00) - 0.5;                                          //LOCATION(179, noise/shaders/classicnoise4D.glsl)
>  gy00 = fract(gy00) - 0.5;                                          //LOCATION(180, noise/shaders/classicnoise4D.glsl)
>  gz00 = fract(gz00) - 0.5;                                          //LOCATION(181, noise/shaders/classicnoise4D.glsl)
>  vec4 gw00 = vec4(0.75) - abs(gx00) - abs(gy00) - abs(gz00);        //LOCATION(182, noise/shaders/classicnoise4D.glsl)
>  vec4 sw00 = step(gw00, vec4(0.0));                                 //LOCATION(183, noise/shaders/classicnoise4D.glsl)
>  gx00 -= sw00 * (step(0.0, gx00) - 0.5);                            //LOCATION(184, noise/shaders/classicnoise4D.glsl)
>  gy00 -= sw00 * (step(0.0, gy00) - 0.5);                            //LOCATION(185, noise/shaders/classicnoise4D.glsl)
>                                                                     //LOCATION(186, noise/shaders/classicnoise4D.glsl)
>  vec4 gx01 = ixy01 * (1.0 / 7.0);                                   //LOCATION(187, noise/shaders/classicnoise4D.glsl)
>  vec4 gy01 = floor(gx01) * (1.0 / 7.0);                             //LOCATION(188, noise/shaders/classicnoise4D.glsl)
>  vec4 gz01 = floor(gy01) * (1.0 / 6.0);                             //LOCATION(189, noise/shaders/classicnoise4D.glsl)
>  gx01 = fract(gx01) - 0.5;                                          //LOCATION(190, noise/shaders/classicnoise4D.glsl)
>  gy01 = fract(gy01) - 0.5;                                          //LOCATION(191, noise/shaders/classicnoise4D.glsl)
>  gz01 = fract(gz01) - 0.5;                                          //LOCATION(192, noise/shaders/classicnoise4D.glsl)
>  vec4 gw01 = vec4(0.75) - abs(gx01) - abs(gy01) - abs(gz01);        //LOCATION(193, noise/shaders/classicnoise4D.glsl)
>  vec4 sw01 = step(gw01, vec4(0.0));                                 //LOCATION(194, noise/shaders/classicnoise4D.glsl)
>  gx01 -= sw01 * (step(0.0, gx01) - 0.5);                            //LOCATION(195, noise/shaders/classicnoise4D.glsl)
>  gy01 -= sw01 * (step(0.0, gy01) - 0.5);                            //LOCATION(196, noise/shaders/classicnoise4D.glsl)
>                                                                     //LOCATION(197, noise/shaders/classicnoise4D.glsl)
>  vec4 gx10 = ixy10 * (1.0 / 7.0);                                   //LOCATION(198, noise/shaders/classicnoise4D.glsl)
>  vec4 gy10 = floor(gx10) * (1.0 / 7.0);                             //LOCATION(199, noise/shaders/classicnoise4D.glsl)
>  vec4 gz10 = floor(gy10) * (1.0 / 6.0);                             //LOCATION(200, noise/shaders/classicnoise4D.glsl)
>  gx10 = fract(gx10) - 0.5;                                          //LOCATION(201, noise/shaders/classicnoise4D.glsl)
>  gy10 = fract(gy10) - 0.5;                                          //LOCATION(202, noise/shaders/classicnoise4D.glsl)
>  gz10 = fract(gz10) - 0.5;                                          //LOCATION(203, noise/shaders/classicnoise4D.glsl)
>  vec4 gw10 = vec4(0.75) - abs(gx10) - abs(gy10) - abs(gz10);        //LOCATION(204, noise/shaders/classicnoise4D.glsl)
>  vec4 sw10 = step(gw10, vec4(0.0));                                 //LOCATION(205, noise/shaders/classicnoise4D.glsl)
>  gx10 -= sw10 * (step(0.0, gx10) - 0.5);                            //LOCATION(206, noise/shaders/classicnoise4D.glsl)
>  gy10 -= sw10 * (step(0.0, gy10) - 0.5);                            //LOCATION(207, noise/shaders/classicnoise4D.glsl)
>                                                                     //LOCATION(208, noise/shaders/classicnoise4D.glsl)
>  vec4 gx11 = ixy11 * (1.0 / 7.0);                                   //LOCATION(209, noise/shaders/classicnoise4D.glsl)
>  vec4 gy11 = floor(gx11) * (1.0 / 7.0);                             //LOCATION(210, noise/shaders/classicnoise4D.glsl)
>  vec4 gz11 = floor(gy11) * (1.0 / 6.0);                             //LOCATION(211, noise/shaders/classicnoise4D.glsl)
>  gx11 = fract(gx11) - 0.5;                                          //LOCATION(212, noise/shaders/classicnoise4D.glsl)
>  gy11 = fract(gy11) - 0.5;                                          //LOCATION(213, noise/shaders/classicnoise4D.glsl)
>  gz11 = fract(gz11) - 0.5;                                          //LOCATION(214, noise/shaders/classicnoise4D.glsl)
>  vec4 gw11 = vec4(0.75) - abs(gx11) - abs(gy11) - abs(gz11);        //LOCATION(215, noise/shaders/classicnoise4D.glsl)
>  vec4 sw11 = step(gw11, vec4(0.0));                                 //LOCATION(216, noise/shaders/classicnoise4D.glsl)
>  gx11 -= sw11 * (step(0.0, gx11) - 0.5);                            //LOCATION(217, noise/shaders/classicnoise4D.glsl)
>  gy11 -= sw11 * (step(0.0, gy11) - 0.5);                            //LOCATION(218, noise/shaders/classicnoise4D.glsl)
>                                                                     //LOCATION(219, noise/shaders/classicnoise4D.glsl)
>  vec4 g0000 = vec4(gx00.x,gy00.x,gz00.x,gw00.x);                    //LOCATION(220, noise/shaders/classicnoise4D.glsl)
>  vec4 g1000 = vec4(gx00.y,gy00.y,gz00.y,gw00.y);                    //LOCATION(221, noise/shaders/classicnoise4D.glsl)
>  vec4 g0100 = vec4(gx00.z,gy00.z,gz00.z,gw00.z);                    //LOCATION(222, noise/shaders/classicnoise4D.glsl)
>  vec4 g1100 = vec4(gx00.w,gy00.w,gz00.w,gw00.w);                    //LOCATION(223, noise/shaders/classicnoise4D.glsl)
>  vec4 g0010 = vec4(gx10.x,gy10.x,gz10.x,gw10.x);                    //LOCATION(224, noise/shaders/classicnoise4D.glsl)
>  vec4 g1010 = vec4(gx10.y,gy10.y,gz10.y,gw10.y);                    //LOCATION(225, noise/shaders/classicnoise4D.glsl)
>  vec4 g0110 = vec4(gx10.z,gy10.z,gz10.z,gw10.z);                    //LOCATION(226, noise/shaders/classicnoise4D.glsl)
>  vec4 g1110 = vec4(gx10.w,gy10.w,gz10.w,gw10.w);                    //LOCATION(227, noise/shaders/classicnoise4D.glsl)
>  vec4 g0001 = vec4(gx01.x,gy01.x,gz01.x,gw01.x);                    //LOCATION(228, noise/shaders/classicnoise4D.glsl)
>  vec4 g1001 = vec4(gx01.y,gy01.y,gz01.y,gw01.y);                    //LOCATION(229, noise/shaders/classicnoise4D.glsl)
>  vec4 g0101 = vec4(gx01.z,gy01.z,gz01.z,gw01.z);                    //LOCATION(230, noise/shaders/classicnoise4D.glsl)
>  vec4 g1101 = vec4(gx01.w,gy01.w,gz01.w,gw01.w);                    //LOCATION(231, noise/shaders/classicnoise4D.glsl)
>  vec4 g0011 = vec4(gx11.x,gy11.x,gz11.x,gw11.x);                    //LOCATION(232, noise/shaders/classicnoise4D.glsl)
>  vec4 g1011 = vec4(gx11.y,gy11.y,gz11.y,gw11.y);                    //LOCATION(233, noise/shaders/classicnoise4D.glsl)
>  vec4 g0111 = vec4(gx11.z,gy11.z,gz11.z,gw11.z);                    //LOCATION(234, noise/shaders/classicnoise4D.glsl)
>  vec4 g1111 = vec4(gx11.w,gy11.w,gz11.w,gw11.w);                    //LOCATION(235, noise/shaders/classicnoise4D.glsl)
>                                                                     //LOCATION(236, noise/shaders/classicnoise4D.glsl)
>  vec4 norm00 = taylorInvSqrt(vec4(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100)));  //LOCATION(237, noise/shaders/classicnoise4D.glsl)
>  g0000 *= norm00.x;                                                 //LOCATION(238, noise/shaders/classicnoise4D.glsl)
>  g0100 *= norm00.y;                                                 //LOCATION(239, noise/shaders/classicnoise4D.glsl)
>  g1000 *= norm00.z;                                                 //LOCATION(240, noise/shaders/classicnoise4D.glsl)
>  g1100 *= norm00.w;                                                 //LOCATION(241, noise/shaders/classicnoise4D.glsl)
>                                                                     //LOCATION(242, noise/shaders/classicnoise4D.glsl)
>  vec4 norm01 = taylorInvSqrt(vec4(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101)));  //LOCATION(243, noise/shaders/classicnoise4D.glsl)
>  g0001 *= norm01.x;                                                 //LOCATION(244, noise/shaders/classicnoise4D.glsl)
>  g0101 *= norm01.y;                                                 //LOCATION(245, noise/shaders/classicnoise4D.glsl)
>  g1001 *= norm01.z;                                                 //LOCATION(246, noise/shaders/classicnoise4D.glsl)
>  g1101 *= norm01.w;                                                 //LOCATION(247, noise/shaders/classicnoise4D.glsl)
>                                                                     //LOCATION(248, noise/shaders/classicnoise4D.glsl)
>  vec4 norm10 = taylorInvSqrt(vec4(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110)));  //LOCATION(249, noise/shaders/classicnoise4D.glsl)
>  g0010 *= norm10.x;                                                 //LOCATION(250, noise/shaders/classicnoise4D.glsl)
>  g0110 *= norm10.y;                                                 //LOCATION(251, noise/shaders/classicnoise4D.glsl)
>  g1010 *= norm10.z;                                                 //LOCATION(252, noise/shaders/classicnoise4D.glsl)
>  g1110 *= norm10.w;                                                 //LOCATION(253, noise/shaders/classicnoise4D.glsl)
>                                                                     //LOCATION(254, noise/shaders/classicnoise4D.glsl)
>  vec4 norm11 = taylorInvSqrt(vec4(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111)));  //LOCATION(255, noise/shaders/classicnoise4D.glsl)
>  g0011 *= norm11.x;                                                 //LOCATION(256, noise/shaders/classicnoise4D.glsl)
>  g0111 *= norm11.y;                                                 //LOCATION(257, noise/shaders/classicnoise4D.glsl)
>  g1011 *= norm11.z;                                                 //LOCATION(258, noise/shaders/classicnoise4D.glsl)
>  g1111 *= norm11.w;                                                 //LOCATION(259, noise/shaders/classicnoise4D.glsl)
>                                                                     //LOCATION(260, noise/shaders/classicnoise4D.glsl)
>  float n0000 = dot(g0000, Pf0);                                     //LOCATION(261, noise/shaders/classicnoise4D.glsl)
>  float n1000 = dot(g1000, vec4(Pf1.x, Pf0.yzw));                    //LOCATION(262, noise/shaders/classicnoise4D.glsl)
>  float n0100 = dot(g0100, vec4(Pf0.x, Pf1.y, Pf0.zw));              //LOCATION(263, noise/shaders/classicnoise4D.glsl)
>  float n1100 = dot(g1100, vec4(Pf1.xy, Pf0.zw));                    //LOCATION(264, noise/shaders/classicnoise4D.glsl)
>  float n0010 = dot(g0010, vec4(Pf0.xy, Pf1.z, Pf0.w));              //LOCATION(265, noise/shaders/classicnoise4D.glsl)
>  float n1010 = dot(g1010, vec4(Pf1.x, Pf0.y, Pf1.z, Pf0.w));        //LOCATION(266, noise/shaders/classicnoise4D.glsl)
>  float n0110 = dot(g0110, vec4(Pf0.x, Pf1.yz, Pf0.w));              //LOCATION(267, noise/shaders/classicnoise4D.glsl)
>  float n1110 = dot(g1110, vec4(Pf1.xyz, Pf0.w));                    //LOCATION(268, noise/shaders/classicnoise4D.glsl)
>  float n0001 = dot(g0001, vec4(Pf0.xyz, Pf1.w));                    //LOCATION(269, noise/shaders/classicnoise4D.glsl)
>  float n1001 = dot(g1001, vec4(Pf1.x, Pf0.yz, Pf1.w));              //LOCATION(270, noise/shaders/classicnoise4D.glsl)
>  float n0101 = dot(g0101, vec4(Pf0.x, Pf1.y, Pf0.z, Pf1.w));        //LOCATION(271, noise/shaders/classicnoise4D.glsl)
>  float n1101 = dot(g1101, vec4(Pf1.xy, Pf0.z, Pf1.w));              //LOCATION(272, noise/shaders/classicnoise4D.glsl)
>  float n0011 = dot(g0011, vec4(Pf0.xy, Pf1.zw));                    //LOCATION(273, noise/shaders/classicnoise4D.glsl)
>  float n1011 = dot(g1011, vec4(Pf1.x, Pf0.y, Pf1.zw));              //LOCATION(274, noise/shaders/classicnoise4D.glsl)
>  float n0111 = dot(g0111, vec4(Pf0.x, Pf1.yzw));                    //LOCATION(275, noise/shaders/classicnoise4D.glsl)
>  float n1111 = dot(g1111, Pf1);                                     //LOCATION(276, noise/shaders/classicnoise4D.glsl)
>                                                                     //LOCATION(277, noise/shaders/classicnoise4D.glsl)
>  vec4 fade_xyzw = fade(Pf0);                                        //LOCATION(278, noise/shaders/classicnoise4D.glsl)
>  vec4 n_0w = mix(vec4(n0000, n1000, n0100, n1100), vec4(n0001, n1001, n0101, n1101), fade_xyzw.w);  //LOCATION(279, noise/shaders/classicnoise4D.glsl)
>  vec4 n_1w = mix(vec4(n0010, n1010, n0110, n1110), vec4(n0011, n1011, n0111, n1111), fade_xyzw.w);  //LOCATION(280, noise/shaders/classicnoise4D.glsl)
>  vec4 n_zw = mix(n_0w, n_1w, fade_xyzw.z);                          //LOCATION(281, noise/shaders/classicnoise4D.glsl)
>  vec2 n_yzw = mix(n_zw.xy, n_zw.zw, fade_xyzw.y);                   //LOCATION(282, noise/shaders/classicnoise4D.glsl)
>  float n_xyzw = mix(n_yzw.x, n_yzw.y, fade_xyzw.x);                 //LOCATION(283, noise/shaders/classicnoise4D.glsl)
>  return 2.2 * n_xyzw;                                               //LOCATION(284, noise/shaders/classicnoise4D.glsl)
>}                                                                    //LOCATION(285, noise/shaders/classicnoise4D.glsl)
>//                                                                   //LOCATION(  1, noise/shaders/noise4D.glsl)
>// Description : Array and textureless GLSL 2D/3D/4D simplex         //LOCATION(  2, noise/shaders/noise4D.glsl)
>//               noise functions.                                    //LOCATION(  3, noise/shaders/noise4D.glsl)
>//      Author : Ian McEwan, Ashima Arts.                            //LOCATION(  4, noise/shaders/noise4D.glsl)
>//  Maintainer : ijm                                                 //LOCATION(  5, noise/shaders/noise4D.glsl)
>//     Lastmod : 20110822 (ijm)                                      //LOCATION(  6, noise/shaders/noise4D.glsl)
>//     License : Copyright (C) 2011 Ashima Arts. All rights reserved.  //LOCATION(  7, noise/shaders/noise4D.glsl)
>//               Distributed under the MIT License. See LICENSE file.  //LOCATION(  8, noise/shaders/noise4D.glsl)
>//               https://github.com/ashima/webgl-noise               //LOCATION(  9, noise/shaders/noise4D.glsl)
>//                                                                   //LOCATION( 10, noise/shaders/noise4D.glsl)
>                                                                     //LOCATION( 11, noise/shaders/noise4D.glsl)
>                                                                     //LOCATION( 12, noise/shaders/noise4D.glsl)
>                                                                     //LOCATION( 13, noise/shaders/noise4D.glsl)
>vec4 grad4(float j, vec4 ip)                                         //LOCATION( 14, noise/shaders/noise4D.glsl)
>  {                                                                  //LOCATION( 15, noise/shaders/noise4D.glsl)
>  const vec4 ones = vec4(1.0, 1.0, 1.0, -1.0);                       //LOCATION( 16, noise/shaders/noise4D.glsl)
>  vec4 p,s;                                                          //LOCATION( 17, noise/shaders/noise4D.glsl)
>                                                                     //LOCATION( 18, noise/shaders/noise4D.glsl)
>  p.xyz = floor( fract (vec3(j) * ip.xyz) * 7.0) * ip.z - 1.0;       //LOCATION( 19, noise/shaders/noise4D.glsl)
>  p.w = 1.5 - dot(abs(p.xyz), ones.xyz);                             //LOCATION( 20, noise/shaders/noise4D.glsl)
>  s = vec4(lessThan(p, vec4(0.0)));                                  //LOCATION( 21, noise/shaders/noise4D.glsl)
>  p.xyz = p.xyz + (s.xyz*2.0 - 1.0) * s.www;                         //LOCATION( 22, noise/shaders/noise4D.glsl)
>                                                                     //LOCATION( 23, noise/shaders/noise4D.glsl)
>  return p;                                                          //LOCATION( 24, noise/shaders/noise4D.glsl)
>  }                                                                  //LOCATION( 25, noise/shaders/noise4D.glsl)
>						                                                               //LOCATION( 26, noise/shaders/noise4D.glsl)
>// (sqrt(5) - 1)/4 = F4, used once below                             //LOCATION( 27, noise/shaders/noise4D.glsl)
>#define F4 0.309016994374947451                                      //LOCATION( 28, noise/shaders/noise4D.glsl)
>                                                                     //LOCATION( 29, noise/shaders/noise4D.glsl)
>float snoise(vec4 v)                                                 //LOCATION( 30, noise/shaders/noise4D.glsl)
>  {                                                                  //LOCATION( 31, noise/shaders/noise4D.glsl)
>  const vec4  C = vec4( 0.138196601125011,  // (5 - sqrt(5))/20  G4  //LOCATION( 32, noise/shaders/noise4D.glsl)
>                        0.276393202250021,  // 2 * G4                //LOCATION( 33, noise/shaders/noise4D.glsl)
>                        0.414589803375032,  // 3 * G4                //LOCATION( 34, noise/shaders/noise4D.glsl)
>                       -0.447213595499958); // -1 + 4 * G4           //LOCATION( 35, noise/shaders/noise4D.glsl)
>                                                                     //LOCATION( 36, noise/shaders/noise4D.glsl)
>// First corner                                                      //LOCATION( 37, noise/shaders/noise4D.glsl)
>  vec4 i  = floor(v + dot(v, vec4(F4)) );                            //LOCATION( 38, noise/shaders/noise4D.glsl)
>  vec4 x0 = v -   i + dot(i, C.xxxx);                                //LOCATION( 39, noise/shaders/noise4D.glsl)
>                                                                     //LOCATION( 40, noise/shaders/noise4D.glsl)
>// Other corners                                                     //LOCATION( 41, noise/shaders/noise4D.glsl)
>                                                                     //LOCATION( 42, noise/shaders/noise4D.glsl)
>// Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI)  //LOCATION( 43, noise/shaders/noise4D.glsl)
>  vec4 i0;                                                           //LOCATION( 44, noise/shaders/noise4D.glsl)
>  vec3 isX = step( x0.yzw, x0.xxx );                                 //LOCATION( 45, noise/shaders/noise4D.glsl)
>  vec3 isYZ = step( x0.zww, x0.yyz );                                //LOCATION( 46, noise/shaders/noise4D.glsl)
>//  i0.x = dot( isX, vec3( 1.0 ) );                                  //LOCATION( 47, noise/shaders/noise4D.glsl)
>  i0.x = isX.x + isX.y + isX.z;                                      //LOCATION( 48, noise/shaders/noise4D.glsl)
>  i0.yzw = 1.0 - isX;                                                //LOCATION( 49, noise/shaders/noise4D.glsl)
>//  i0.y += dot( isYZ.xy, vec2( 1.0 ) );                             //LOCATION( 50, noise/shaders/noise4D.glsl)
>  i0.y += isYZ.x + isYZ.y;                                           //LOCATION( 51, noise/shaders/noise4D.glsl)
>  i0.zw += 1.0 - isYZ.xy;                                            //LOCATION( 52, noise/shaders/noise4D.glsl)
>  i0.z += isYZ.z;                                                    //LOCATION( 53, noise/shaders/noise4D.glsl)
>  i0.w += 1.0 - isYZ.z;                                              //LOCATION( 54, noise/shaders/noise4D.glsl)
>                                                                     //LOCATION( 55, noise/shaders/noise4D.glsl)
>  // i0 now contains the unique values 0,1,2,3 in each channel       //LOCATION( 56, noise/shaders/noise4D.glsl)
>  vec4 i3 = clamp( i0, 0.0, 1.0 );                                   //LOCATION( 57, noise/shaders/noise4D.glsl)
>  vec4 i2 = clamp( i0-1.0, 0.0, 1.0 );                               //LOCATION( 58, noise/shaders/noise4D.glsl)
>  vec4 i1 = clamp( i0-2.0, 0.0, 1.0 );                               //LOCATION( 59, noise/shaders/noise4D.glsl)
>                                                                     //LOCATION( 60, noise/shaders/noise4D.glsl)
>  //  x0 = x0 - 0.0 + 0.0 * C.xxxx                                   //LOCATION( 61, noise/shaders/noise4D.glsl)
>  //  x1 = x0 - i1  + 1.0 * C.xxxx                                   //LOCATION( 62, noise/shaders/noise4D.glsl)
>  //  x2 = x0 - i2  + 2.0 * C.xxxx                                   //LOCATION( 63, noise/shaders/noise4D.glsl)
>  //  x3 = x0 - i3  + 3.0 * C.xxxx                                   //LOCATION( 64, noise/shaders/noise4D.glsl)
>  //  x4 = x0 - 1.0 + 4.0 * C.xxxx                                   //LOCATION( 65, noise/shaders/noise4D.glsl)
>  vec4 x1 = x0 - i1 + C.xxxx;                                        //LOCATION( 66, noise/shaders/noise4D.glsl)
>  vec4 x2 = x0 - i2 + C.yyyy;                                        //LOCATION( 67, noise/shaders/noise4D.glsl)
>  vec4 x3 = x0 - i3 + C.zzzz;                                        //LOCATION( 68, noise/shaders/noise4D.glsl)
>  vec4 x4 = x0 + C.wwww;                                             //LOCATION( 69, noise/shaders/noise4D.glsl)
>                                                                     //LOCATION( 70, noise/shaders/noise4D.glsl)
>// Permutations                                                      //LOCATION( 71, noise/shaders/noise4D.glsl)
>  i = mod289(i);                                                     //LOCATION( 72, noise/shaders/noise4D.glsl)
>  float j0 = permute( permute( permute( permute(i.w) + i.z) + i.y) + i.x);  //LOCATION( 73, noise/shaders/noise4D.glsl)
>  vec4 j1 = permute( permute( permute( permute (                     //LOCATION( 74, noise/shaders/noise4D.glsl)
>             i.w + vec4(i1.w, i2.w, i3.w, 1.0 ))                     //LOCATION( 75, noise/shaders/noise4D.glsl)
>           + i.z + vec4(i1.z, i2.z, i3.z, 1.0 ))                     //LOCATION( 76, noise/shaders/noise4D.glsl)
>           + i.y + vec4(i1.y, i2.y, i3.y, 1.0 ))                     //LOCATION( 77, noise/shaders/noise4D.glsl)
>           + i.x + vec4(i1.x, i2.x, i3.x, 1.0 ));                    //LOCATION( 78, noise/shaders/noise4D.glsl)
>                                                                     //LOCATION( 79, noise/shaders/noise4D.glsl)
>// Gradients: 7x7x6 points over a cube, mapped onto a 4-cross polytope  //LOCATION( 80, noise/shaders/noise4D.glsl)
>// 7*7*6 = 294, which is close to the ring size 17*17 = 289.         //LOCATION( 81, noise/shaders/noise4D.glsl)
>  vec4 ip = vec4(1.0/294.0, 1.0/49.0, 1.0/7.0, 0.0) ;                //LOCATION( 82, noise/shaders/noise4D.glsl)
>                                                                     //LOCATION( 83, noise/shaders/noise4D.glsl)
>  vec4 p0 = grad4(j0,   ip);                                         //LOCATION( 84, noise/shaders/noise4D.glsl)
>  vec4 p1 = grad4(j1.x, ip);                                         //LOCATION( 85, noise/shaders/noise4D.glsl)
>  vec4 p2 = grad4(j1.y, ip);                                         //LOCATION( 86, noise/shaders/noise4D.glsl)
>  vec4 p3 = grad4(j1.z, ip);                                         //LOCATION( 87, noise/shaders/noise4D.glsl)
>  vec4 p4 = grad4(j1.w, ip);                                         //LOCATION( 88, noise/shaders/noise4D.glsl)
>                                                                     //LOCATION( 89, noise/shaders/noise4D.glsl)
>// Normalise gradients                                               //LOCATION( 90, noise/shaders/noise4D.glsl)
>  vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));  //LOCATION( 91, noise/shaders/noise4D.glsl)
>  p0 *= norm.x;                                                      //LOCATION( 92, noise/shaders/noise4D.glsl)
>  p1 *= norm.y;                                                      //LOCATION( 93, noise/shaders/noise4D.glsl)
>  p2 *= norm.z;                                                      //LOCATION( 94, noise/shaders/noise4D.glsl)
>  p3 *= norm.w;                                                      //LOCATION( 95, noise/shaders/noise4D.glsl)
>  p4 *= taylorInvSqrt(dot(p4,p4));                                   //LOCATION( 96, noise/shaders/noise4D.glsl)
>                                                                     //LOCATION( 97, noise/shaders/noise4D.glsl)
>// Mix contributions from the five corners                           //LOCATION( 98, noise/shaders/noise4D.glsl)
>  vec3 m0 = max(0.6 - vec3(dot(x0,x0), dot(x1,x1), dot(x2,x2)), 0.0);  //LOCATION( 99, noise/shaders/noise4D.glsl)
>  vec2 m1 = max(0.6 - vec2(dot(x3,x3), dot(x4,x4)            ), 0.0);  //LOCATION(100, noise/shaders/noise4D.glsl)
>  m0 = m0 * m0;                                                      //LOCATION(101, noise/shaders/noise4D.glsl)
>  m1 = m1 * m1;                                                      //LOCATION(102, noise/shaders/noise4D.glsl)
>  return 49.0 * ( dot(m0*m0, vec3( dot( p0, x0 ), dot( p1, x1 ), dot( p2, x2 )))  //LOCATION(103, noise/shaders/noise4D.glsl)
>               + dot(m1*m1, vec2( dot( p3, x3 ), dot( p4, x4 ) ) ) ) ;  //LOCATION(104, noise/shaders/noise4D.glsl)
>                                                                     //LOCATION(105, noise/shaders/noise4D.glsl)
>  }                                                                  //LOCATION(106, noise/shaders/noise4D.glsl)
>                                                                     //LOCATION(  1, raw string)
>float NOISE_FUNC(vec2 x);                                            //LOCATION(  2, raw string)
>                                                                     //LOCATION(  1, noise/shaders/frag.glsl)
>varying vec2 w;                                                      //LOCATION(  2, noise/shaders/frag.glsl)
>                                                                     //LOCATION(  3, noise/shaders/frag.glsl)
>                                                                     //LOCATION(  4, noise/shaders/frag.glsl)
>                                                                     //LOCATION(  5, noise/shaders/frag.glsl)
>uniform float time_s;                                                //LOCATION(  6, noise/shaders/frag.glsl)
>uniform float time_ms;                                               //LOCATION(  7, noise/shaders/frag.glsl)
>                                                                     //LOCATION(  8, noise/shaders/frag.glsl)
>float time_dependent(void)                                           //LOCATION(  9, noise/shaders/frag.glsl)
>{                                                                    //LOCATION( 10, noise/shaders/frag.glsl)
>  return time_s*2.0 + time_ms/500.0;                                 //LOCATION( 11, noise/shaders/frag.glsl)
>}                                                                    //LOCATION( 12, noise/shaders/frag.glsl)
>                                                                     //LOCATION( 13, noise/shaders/frag.glsl)
>float noise_value(vec2 q)                                            //LOCATION( 14, noise/shaders/frag.glsl)
>{                                                                    //LOCATION( 15, noise/shaders/frag.glsl)
>   float R;                                                          //LOCATION( 16, noise/shaders/frag.glsl)
>   R=NOISE_FUNC(q);                                                  //LOCATION( 17, noise/shaders/frag.glsl)
>   return 0.5*(R+1.0);                                               //LOCATION( 18, noise/shaders/frag.glsl)
>}                                                                    //LOCATION( 19, noise/shaders/frag.glsl)
>                                                                     //LOCATION( 20, noise/shaders/frag.glsl)
>void main(void)                                                      //LOCATION( 21, noise/shaders/frag.glsl)
>{                                                                    //LOCATION( 22, noise/shaders/frag.glsl)
>	float r, g, b;                                                      //LOCATION( 23, noise/shaders/frag.glsl)
>	vec2 xy;                                                            //LOCATION( 24, noise/shaders/frag.glsl)
>	float omega;                                                        //LOCATION( 25, noise/shaders/frag.glsl)
>                                                                     //LOCATION( 26, noise/shaders/frag.glsl)
>	omega= (time_s + time_ms/1000.0)*2.0*3.14159/5.0;                   //LOCATION( 27, noise/shaders/frag.glsl)
>	xy=float(CircleRadius)*vec2(cos(omega), sin(omega));                //LOCATION( 28, noise/shaders/frag.glsl)
>                                                                     //LOCATION( 29, noise/shaders/frag.glsl)
>	                                                                    //LOCATION( 30, noise/shaders/frag.glsl)
>	r=noise_value(w+xy);                                                //LOCATION( 31, noise/shaders/frag.glsl)
>	#ifdef GREY_SCALE_NOISE                                             //LOCATION( 32, noise/shaders/frag.glsl)
>	{                                                                   //LOCATION( 33, noise/shaders/frag.glsl)
>	  g=r;                                                              //LOCATION( 34, noise/shaders/frag.glsl)
>	  b=r;                                                              //LOCATION( 35, noise/shaders/frag.glsl)
>	}                                                                   //LOCATION( 36, noise/shaders/frag.glsl)
>	#else                                                               //LOCATION( 37, noise/shaders/frag.glsl)
>	{                                                                   //LOCATION( 38, noise/shaders/frag.glsl)
>	  g=noise_value(w+xy+vec2(12.0, 3.0));                              //LOCATION( 39, noise/shaders/frag.glsl)
>	  b=noise_value(w+xy+vec2(3.0, 56.0));                              //LOCATION( 40, noise/shaders/frag.glsl)
>	}                                                                   //LOCATION( 41, noise/shaders/frag.glsl)
>	#endif                                                              //LOCATION( 42, noise/shaders/frag.glsl)
>                                                                     //LOCATION( 43, noise/shaders/frag.glsl)
>	gl_FragColor=vec4(r,g,b,1.0);                                       //LOCATION( 44, noise/shaders/frag.glsl)
>}                                                                    //LOCATION( 45, noise/shaders/frag.glsl)
>                                                                     //LOCATION(  1, raw string)
>float NOISE_FUNC(vec2 x) { return pnoise(vec4(x, time_dependent(), time_dependent()/2.0) ); }  //LOCATION(  2, raw string)

Actions: View

Attachments on bug 70613: 87818 | 87819 | 87820

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.