From: Eleni Maria Stea <elene.mst@gmail.com>
Date: Mon, 1 Oct 2018 19:11:01 +0000 (+0300)
Subject: clouds and better light beam
X-Git-Url: http://git.mutantstargoat.com?p=lighthouse;a=commitdiff_plain;h=b9f859fddd8d2e482a6fbcfe37828b64865a8727

clouds and better light beam
---

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..a5c0a51
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,4 @@
+*.o
+*.d
+*.swp
+faros
diff --git a/sdr/beam.v.glsl b/sdr/beam.v.glsl
index a823e8b..6ea5003 100644
--- a/sdr/beam.v.glsl
+++ b/sdr/beam.v.glsl
@@ -1,9 +1,15 @@
+uniform float beam_len;
+
 void main()
 {
-	float s = gl_Vertex.z + 1.0;
+	float dist = gl_Vertex.z;
+	float s = (dist + 1.0) * 1.6;
 
 	vec4 pos = gl_Vertex * vec4(s, s, 1.0, 1.0);
 
 	gl_Position = gl_ModelViewProjectionMatrix * pos;
-	gl_FrontColor = gl_Color;
+
+	float d = dist / beam_len;
+	float falloff = min(1.0 - d, 1.0);
+	gl_FrontColor = vec4(gl_Color.xyz, gl_Color.a * falloff);
 }
diff --git a/sdr/sky.f.glsl b/sdr/sky.f.glsl
index 1767b42..4b830fe 100644
--- a/sdr/sky.f.glsl
+++ b/sdr/sky.f.glsl
@@ -1,92 +1,157 @@
-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)
diff --git a/sdr/sky.v.glsl b/sdr/sky.v.glsl
index 776bbce..cf0b11c 100644
--- a/sdr/sky.v.glsl
+++ b/sdr/sky.v.glsl
@@ -1,9 +1,7 @@
+varying vec3 local_pos;
+
 void main()
 {
 	gl_Position = ftransform();
-
-	vec3 p = normalize(gl_Vertex.xyz);
-	vec2 uv = vec2(atan(p.z, p.x), asin(p.y));
-
-	gl_TexCoord[0] = vec4(uv, 0.0, 0.0);
+	local_pos = gl_Vertex.xyz;
 }
diff --git a/src/main.cc b/src/main.cc
index 669ede3..0284a42 100644
--- a/src/main.cc
+++ b/src/main.cc
@@ -15,6 +15,7 @@
 #define BEAM_RMIN 0.01
 #define BEAM_RMAX 0.125
 #define BEAM_ENERGY 0.02
+#define BEAM_LEN 16.0
 
 static bool init();
 static void cleanup();
@@ -36,6 +37,9 @@ static unsigned int sdr_curve_top, sdr_beam, sdr_sky;
 static unsigned int start_time;
 static float beam_rot_speed = 0.1;
 
+static const float sil_color[] = {0.05, 0.02, 0.1, 1.0};
+static const float beam_color[] = {0.5, 0.4, 0.2, 1.0};
+
 int main(int argc, char **argv)
 {
 	glutInit(&argc, argv);
@@ -94,7 +98,7 @@ static void cleanup()
 
 static void faros()
 {
-	glColor3f(0, 0, 0);
+	glColor3fv(sil_color);
 
 	// kormos
 	glPushMatrix();
@@ -184,6 +188,7 @@ static void light()
 
 	glTranslatef(0, 4.65, 0.2);
 	bind_program(sdr_beam);
+	set_uniform_float(sdr_beam, "beam_len", BEAM_LEN);
 
 	glEnable(GL_BLEND);
 	glBlendFunc(GL_SRC_ALPHA, GL_ONE);
@@ -191,11 +196,11 @@ static void light()
 	for(int i=0; i<BEAM_SHELLS; i++) {
 		float t = (float)i / (float)(BEAM_SHELLS - 1);
 		float rad = BEAM_RMIN + (BEAM_RMAX - BEAM_RMIN) * t;
-		float alpha = BEAM_ENERGY / t;
+		float alpha = BEAM_ENERGY / (t * t);
 
-		glColor4f(0.8, 0.8, 0.2, alpha);
+		glColor4f(beam_color[0], beam_color[1], beam_color[2], alpha);
 
-		glutSolidCylinder(rad, 6, 10, 1);
+		glutSolidCylinder(rad, BEAM_LEN, 12, 1);
 	}
 
 	bind_program(0);
@@ -212,7 +217,7 @@ static void ground()
 	glTranslatef(0, -1.25, 0);
 	glScalef(1, 0.1, 1);
 
-	glColor3f(0, 0, 0);
+	glColor3fv(sil_color);
 	glutSolidSphere(10, 32, 32);
 
 	glPopMatrix();