-float pnoise(vec2 P, vec2 rep);
-float pnoise_octaves();
+varying vec3 local_pos;
+
+#define PI 3.141592653589793
+#define TWO_PI (2.0 * PI)
+
+float fbm(vec3 p, int octaves);
+float snoise(vec3 p);
+float clouds(vec3 p);
void main()
{
- float alt = min((gl_TexCoord[0].y + 0.29)* 2.0, 1.0);
- float cloud_dens = 0.5;
+ vec3 lpos = normalize(local_pos);
+
+ float cval = clouds(lpos * vec3(4.5, 4.5, 4.5));
+ float alt = min(lpos.y * 2.0 + 0.5, 1.0);
//const vec3 col_hor = vec3(0.96, 0.55, 0.98);
const vec3 col_hor = vec3(0.95, 0.38, 0.54);
- const vec3 col_zen = vec3(0.05, 0.15, 0.32);
+ const vec3 col_zen = vec3(0.08, 0.18, 0.4);
- gl_FragColor.rgb = mix(col_hor, col_zen, alt);
+ vec3 skycol = mix(col_hor, col_zen, alt);
+
+ gl_FragColor.rgb = mix(skycol, vec3(0.0, 0.0, 0.0), cval);
gl_FragColor.a = 1.0;
}
+const float cloud_dens = 0.25;
+const float cloud_smooth = 1.0;
+const float cloud_alpha = 0.4;
-//
-// GLSL textureless classic 2D noise "cnoise",
-// with an RSL-style periodic variant "pnoise".
-// Author: Stefan Gustavson (stefan.gustavson@liu.se)
-// Version: 2011-08-22
-//
-// Many thanks to Ian McEwan of Ashima Arts for the
-// ideas for permutation and gradient selection.
-//
-// Copyright (c) 2011 Stefan Gustavson. All rights reserved.
-// Distributed under the MIT license. See LICENSE file.
-// https://github.com/ashima/webgl-noise
-//
-
-vec4 mod289(vec4 x)
+float clouds(vec3 p)
{
- return x - floor(x * (1.0 / 289.0)) * 289.0;
+ float hor = clamp(p.y * 2.0, 0.0, 1.0);
+ float nval = fbm(p * vec3(0.2, 1.0, 0.2), 5);
+ float res = smoothstep(cloud_dens - cloud_smooth * 0.5,
+ cloud_dens + cloud_smooth * 0.5, nval);
+ return res * hor * cloud_alpha;
}
-vec4 permute(vec4 x)
+float fbm(vec3 p, int octaves)
{
- return mod289(((x*34.0)+1.0)*x);
+ float res = 0.0;
+ float freq = 1.0;
+ float s = 1.0;
+
+ for(int i=0; i<octaves; i++) {
+ res += snoise(p * freq) * s;
+ freq *= 2.0;
+ s *= 0.5;
+ }
+ return res;
}
-vec4 taylorInvSqrt(vec4 r)
-{
- return 1.79284291400159 - 0.85373472095314 * r;
+//
+// Description : Array and textureless GLSL 2D/3D/4D simplex
+// noise functions.
+// Author : Ian McEwan, Ashima Arts.
+// Maintainer : ijm
+// Lastmod : 20110822 (ijm)
+// License : Copyright (C) 2011 Ashima Arts. All rights reserved.
+// Distributed under the MIT License. See LICENSE file.
+// https://github.com/ashima/webgl-noise
+//
+
+vec3 mod289(vec3 x) {
+ return x - floor(x * (1.0 / 289.0)) * 289.0;
}
-vec2 fade(vec2 t) {
- return t*t*t*(t*(t*6.0-15.0)+10.0);
+vec4 mod289(vec4 x) {
+ return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+
+vec4 permute(vec4 x) {
+ return mod289(((x*34.0)+1.0)*x);
}
-// Classic Perlin noise, periodic variant
-float pnoise(vec2 P, vec2 rep)
+vec4 taylorInvSqrt(vec4 r)
{
- vec4 Pi = floor(P.xyxy) + vec4(0.0, 0.0, 1.0, 1.0);
- vec4 Pf = fract(P.xyxy) - vec4(0.0, 0.0, 1.0, 1.0);
- Pi = mod(Pi, rep.xyxy); // To create noise with explicit period
- Pi = mod289(Pi); // To avoid truncation effects in permutation
- vec4 ix = Pi.xzxz;
- vec4 iy = Pi.yyww;
- vec4 fx = Pf.xzxz;
- vec4 fy = Pf.yyww;
-
- vec4 i = permute(permute(ix) + iy);
-
- vec4 gx = fract(i * (1.0 / 41.0)) * 2.0 - 1.0 ;
- vec4 gy = abs(gx) - 0.5 ;
- vec4 tx = floor(gx + 0.5);
- gx = gx - tx;
-
- vec2 g00 = vec2(gx.x,gy.x);
- vec2 g10 = vec2(gx.y,gy.y);
- vec2 g01 = vec2(gx.z,gy.z);
- vec2 g11 = vec2(gx.w,gy.w);
-
- vec4 norm = taylorInvSqrt(vec4(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));
- g00 *= norm.x;
- g01 *= norm.y;
- g10 *= norm.z;
- g11 *= norm.w;
-
- float n00 = dot(g00, vec2(fx.x, fy.x));
- float n10 = dot(g10, vec2(fx.y, fy.y));
- float n01 = dot(g01, vec2(fx.z, fy.z));
- float n11 = dot(g11, vec2(fx.w, fy.w));
-
- vec2 fade_xy = fade(Pf.xy);
- vec2 n_x = mix(vec2(n00, n01), vec2(n10, n11), fade_xy.x);
- float n_xy = mix(n_x.x, n_x.y, fade_xy.y);
- return 2.3 * n_xy;
+ return 1.79284291400159 - 0.85373472095314 * r;
}
-#pragma glslify: export(pnoise)
+float snoise(vec3 v)
+ {
+ const vec2 C = vec2(1.0/6.0, 1.0/3.0) ;
+ const vec4 D = vec4(0.0, 0.5, 1.0, 2.0);
+
+// First corner
+ vec3 i = floor(v + dot(v, C.yyy) );
+ vec3 x0 = v - i + dot(i, C.xxx) ;
+
+// Other corners
+ vec3 g = step(x0.yzx, x0.xyz);
+ vec3 l = 1.0 - g;
+ vec3 i1 = min( g.xyz, l.zxy );
+ vec3 i2 = max( g.xyz, l.zxy );
+
+ // x0 = x0 - 0.0 + 0.0 * C.xxx;
+ // x1 = x0 - i1 + 1.0 * C.xxx;
+ // x2 = x0 - i2 + 2.0 * C.xxx;
+ // x3 = x0 - 1.0 + 3.0 * C.xxx;
+ vec3 x1 = x0 - i1 + C.xxx;
+ vec3 x2 = x0 - i2 + C.yyy; // 2.0*C.x = 1/3 = C.y
+ vec3 x3 = x0 - D.yyy; // -1.0+3.0*C.x = -0.5 = -D.y
+
+// Permutations
+ i = mod289(i);
+ vec4 p = permute( permute( permute(
+ i.z + vec4(0.0, i1.z, i2.z, 1.0 ))
+ + i.y + vec4(0.0, i1.y, i2.y, 1.0 ))
+ + i.x + vec4(0.0, i1.x, i2.x, 1.0 ));
+
+// Gradients: 7x7 points over a square, mapped onto an octahedron.
+// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
+ float n_ = 0.142857142857; // 1.0/7.0
+ vec3 ns = n_ * D.wyz - D.xzx;
+
+ vec4 j = p - 49.0 * floor(p * ns.z * ns.z); // mod(p,7*7)
+
+ vec4 x_ = floor(j * ns.z);
+ vec4 y_ = floor(j - 7.0 * x_ ); // mod(j,N)
+
+ vec4 x = x_ *ns.x + ns.yyyy;
+ vec4 y = y_ *ns.x + ns.yyyy;
+ vec4 h = 1.0 - abs(x) - abs(y);
+
+ vec4 b0 = vec4( x.xy, y.xy );
+ vec4 b1 = vec4( x.zw, y.zw );
+
+ //vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;
+ //vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;
+ vec4 s0 = floor(b0)*2.0 + 1.0;
+ vec4 s1 = floor(b1)*2.0 + 1.0;
+ vec4 sh = -step(h, vec4(0.0));
+
+ vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ;
+ vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww ;
+
+ vec3 p0 = vec3(a0.xy,h.x);
+ vec3 p1 = vec3(a0.zw,h.y);
+ vec3 p2 = vec3(a1.xy,h.z);
+ vec3 p3 = vec3(a1.zw,h.w);
+
+//Normalise gradients
+ vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));
+ p0 *= norm.x;
+ p1 *= norm.y;
+ p2 *= norm.z;
+ p3 *= norm.w;
+
+// Mix final noise value
+ vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0);
+ m = m * m;
+ return 42.0 * dot( m*m, vec4( dot(p0,x0), dot(p1,x1),
+ dot(p2,x2), dot(p3,x3) ) );
+ }
+
+#pragma glslify: export(snoise)
projects / lighthouse / commitdiff