2 // Description : Array and textureless GLSL 2D/3D/4D simplex
4 // Author : Ian McEwan, Ashima Arts.
6 // Lastmod : 20110822 (ijm)
7 // License : Copyright (C) 2011 Ashima Arts. All rights reserved.
8 // Distributed under the MIT License. See LICENSE file.
9 // https://github.com/ashima/webgl-noise
12 Permission is hereby granted, free of charge, to any person obtaining a copy
13 of this software and associated documentation files (the "Software"), to deal
14 in the Software without restriction, including without limitation the rights
15 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
16 copies of the Software, and to permit persons to whom the Software is
17 furnished to do so, subject to the following conditions:
19 The above copyright notice and this permission notice shall be included in
20 all copies or substantial portions of the Software.
22 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
23 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
24 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
25 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
26 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
27 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
31 precision highp float;
34 return x - floor(x * (1.0 / 289.0)) * 289.0;
38 return x - floor(x * (1.0 / 289.0)) * 289.0;
42 return x - floor(x * (1.0 / 289.0)) * 289.0;
45 vec3 permute(vec3 x) {
46 return mod289(((x*34.0)+1.0)*x);
49 vec4 permute(vec4 x) {
50 return mod289(((x*34.0)+1.0)*x);
53 vec4 taylorInvSqrt(vec4 r)
55 return 1.79284291400159 - 0.85373472095314 * r;
60 const vec2 C = vec2(1.0/6.0, 1.0/3.0) ;
61 const vec4 D = vec4(0.0, 0.5, 1.0, 2.0);
64 vec3 i = floor(v + dot(v, C.yyy) );
65 vec3 x0 = v - i + dot(i, C.xxx) ;
68 vec3 g = step(x0.yzx, x0.xyz);
70 vec3 i1 = min( g.xyz, l.zxy );
71 vec3 i2 = max( g.xyz, l.zxy );
73 // x0 = x0 - 0.0 + 0.0 * C.xxx;
74 // x1 = x0 - i1 + 1.0 * C.xxx;
75 // x2 = x0 - i2 + 2.0 * C.xxx;
76 // x3 = x0 - 1.0 + 3.0 * C.xxx;
77 vec3 x1 = x0 - i1 + C.xxx;
78 vec3 x2 = x0 - i2 + C.yyy; // 2.0*C.x = 1/3 = C.y
79 vec3 x3 = x0 - D.yyy; // -1.0+3.0*C.x = -0.5 = -D.y
83 vec4 p = permute( permute( permute(
84 i.z + vec4(0.0, i1.z, i2.z, 1.0 ))
85 + i.y + vec4(0.0, i1.y, i2.y, 1.0 ))
86 + i.x + vec4(0.0, i1.x, i2.x, 1.0 ));
88 // Gradients: 7x7 points over a square, mapped onto an octahedron.
89 // The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
90 float n_ = 0.142857142857; // 1.0/7.0
91 vec3 ns = n_ * D.wyz - D.xzx;
93 vec4 j = p - 49.0 * floor(p * ns.z * ns.z); // mod(p,7*7)
95 vec4 x_ = floor(j * ns.z);
96 vec4 y_ = floor(j - 7.0 * x_ ); // mod(j,N)
98 vec4 x = x_ *ns.x + ns.yyyy;
99 vec4 y = y_ *ns.x + ns.yyyy;
100 vec4 h = 1.0 - abs(x) - abs(y);
102 vec4 b0 = vec4( x.xy, y.xy );
103 vec4 b1 = vec4( x.zw, y.zw );
105 //vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;
106 //vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;
107 vec4 s0 = floor(b0)*2.0 + 1.0;
108 vec4 s1 = floor(b1)*2.0 + 1.0;
109 vec4 sh = -step(h, vec4(0.0));
111 vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ;
112 vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww ;
114 vec3 p0 = vec3(a0.xy,h.x);
115 vec3 p1 = vec3(a0.zw,h.y);
116 vec3 p2 = vec3(a1.xy,h.z);
117 vec3 p3 = vec3(a1.zw,h.w);
119 //Normalise gradients
120 vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));
126 // Mix final noise value
127 vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0);
129 return 42.0 * dot( m*m, vec4( dot(p0,x0), dot(p1,x1),
130 dot(p2,x2), dot(p3,x3) ) );
135 const vec4 C = vec4(0.211324865405187, // (3.0-sqrt(3.0))/6.0
136 0.366025403784439, // 0.5*(sqrt(3.0)-1.0)
137 -0.577350269189626, // -1.0 + 2.0 * C.x
138 0.024390243902439); // 1.0 / 41.0
140 vec2 i = floor(v + dot(v, C.yy) );
141 vec2 x0 = v - i + dot(i, C.xx);
145 //i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
147 i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
148 // x0 = x0 - 0.0 + 0.0 * C.xx ;
149 // x1 = x0 - i1 + 1.0 * C.xx ;
150 // x2 = x0 - 1.0 + 2.0 * C.xx ;
151 vec4 x12 = x0.xyxy + C.xxzz;
155 i = mod289(i); // Avoid truncation effects in permutation
156 vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 ))
157 + i.x + vec3(0.0, i1.x, 1.0 ));
159 vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0);
163 // Gradients: 41 points uniformly over a line, mapped onto a diamond.
164 // The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
166 vec3 x = 2.0 * fract(p * C.www) - 1.0;
167 vec3 h = abs(x) - 0.5;
168 vec3 ox = floor(x + 0.5);
171 // Normalise gradients implicitly by scaling m
172 // Approximation of: m *= inversesqrt( a0*a0 + h*h );
173 m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h );
175 // Compute final noise value at P
177 g.x = a0.x * x0.x + h.x * x0.y;
178 g.yz = a0.yz * x12.xz + h.yz * x12.yw;
179 return 130.0 * dot(m, g);