Debian Codegraph @

demos/gtk-demo/glowingstars.glsl

raw
1 // Originally from: https://www.shadertoy.com/view/ttBcRV
2 // License CC0: Flying through glowing stars
3 // The result of playing around trying to improve an old shader
4
5 #define PI 3.141592654
6 #define TAU (2.0*PI)
7 #define TIME iTime
8 #define RESOLUTION iResolution
9
10 #define LESS(a,b,c) mix(a,b,step(0.,c))
11 #define SABS(x,k) LESS((.5/(k))*(x)*(x)+(k)*.5,abs(x),abs(x)-(k))
12
13 #define MROT(a) mat2(cos(a), sin(a), -sin(a), cos(a))
14
15 vec3 hsv2rgb(vec3 c) {
16 const vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
17 vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
18 return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
19 }
20
21 float hash(in vec3 co) {
22 return fract(sin(dot(co, vec3(12.9898,58.233, 12.9898+58.233))) * 13758.5453);
23 }
24
25 float starn(vec2 p, float r, int n, float m) {
26 // From IQ: https://www.shadertoy.com/view/3tSGDy
27 // https://iquilezles.org/www/articles/distfunctions2d/distfunctions2d.htm
28
29 // Minor tweak to use SABS over abs to smooth inner corners
30 // SABS: https://www.shadertoy.com/view/Ws2SDK
31
32 // next 4 lines can be precomputed for a given shape
33 float an = 3.141593/float(n);
34 float en = 3.141593/m; // m is between 2 and n
35 vec2 acs = vec2(cos(an),sin(an));
36 vec2 ecs = vec2(cos(en),sin(en)); // ecs=vec2(0,1) for regular polygon,
37
38 float bn = mod(atan(p.x,p.y),2.0*an) - an;
39 p = length(p)*vec2(cos(bn),SABS(sin(bn), 0.15));
40 p -= r*acs;
41 p += ecs*clamp( -dot(p,ecs), 0.0, r*acs.y/ecs.y);
42 return length(p)*sign(p.x);
43 }
44
45 vec4 alphaBlend(vec4 back, vec4 front) {
46 vec3 xyz = mix(back.xyz*back.w, front.xyz, front.w);
47 float w = mix(back.w, 1.0, front.w);
48 return vec4(xyz, w);
49 }
50
51 void rot(inout vec2 p, float a) {
52 float c = cos(a);
53 float s = sin(a);
54 p = vec2(c*p.x + s*p.y, -s*p.x + c*p.y);
55 }
56
57 vec3 offset(float z) {
58 float a = z;
59 vec2 p = -0.075*(vec2(cos(a), sin(a*sqrt(2.0))) + vec2(cos(a*sqrt(0.75)), sin(a*sqrt(0.5))));
60 return vec3(p, z);
61 }
62
63 vec3 doffset(float z) {
64 float eps = 0.05;
65 return 0.5*(offset(z + eps) - offset(z - eps))/eps;
66 }
67
68 vec3 ddoffset(float z) {
69 float eps = 0.05;
70 return 0.5*(doffset(z + eps) - doffset(z - eps))/eps;
71 }
72
73 vec4 planeCol(vec3 ro, vec3 rd, float n, vec3 pp) {
74 const float s = 0.5;
75
76 vec2 p = pp.xy;
77 float z = pp.z;
78 vec2 dpy = dFdy(p);
79 float aa = length(dpy);
80
81 p -= (1.0+5.0*(pp.z - ro.z))*offset(z).xy;
82
83 p *= s;
84 float r = hash(vec3(floor(p+0.5), n));
85 p = fract(p+0.5)-0.5;
86 rot(p, ((TAU*r+n)*0.25));
87 float d = starn(p, 0.20, 3 + 2*int(3.0*r), 3.0);
88 d -= 0.06;
89 d/=s;
90
91 float ds = -d+0.03;
92 vec3 cols = hsv2rgb(vec3(337.0/360.0+0.1*sin(n*0.3), 0.8, 0.54+0.2*sin(n*0.3)));
93 float ts = 1.0 - smoothstep(-aa, 0.0, ds);
94 vec4 cs = vec4(cols, ts*0.93);
95
96 float db = abs(d) - (0.06);
97 db = abs(db) - 0.03;
98 db = abs(db) - 0.00;
99 db = max(db, -d+0.03);
100 vec3 colb = vec3(1.0, 0.7, 0.5);
101 float tb = exp(-(db)*30.0*(1.0 - 10.0*aa));
102 vec4 cb = vec4(1.5*colb, tb);
103
104 vec4 ct = alphaBlend(cs, cb);
105
106 return ct;
107 }
108
109 vec3 color(vec3 ww, vec3 uu, vec3 vv, vec3 ro, vec2 p) {
110 vec3 rd = normalize(p.x*uu + p.y*vv + (2.0-tanh(length(p)))*ww);
111
112 vec4 col = vec4(vec3(0.0), 1.0);
113
114 const float planeDist = 1.0;
115 const int furthest = 6;
116 const int fadeFrom = furthest-3;
117
118 float nz = floor(ro.z / planeDist);
119
120 for (int i = furthest; i >= 1; --i) {
121 float pz = planeDist*nz + planeDist*float(i);
122
123 float pd = (pz - ro.z)/rd.z;
124
125 if (pd > 0.0) {
126 vec3 pp = ro + rd*pd;
127
128 vec4 pcol = planeCol(ro, rd, nz+float(i), pp);
129 float fadeIn = 1.0-smoothstep(planeDist*float(fadeFrom), planeDist*float(furthest), pp.z-ro.z);
130 pcol.xyz *= sqrt(fadeIn);
131
132 col = alphaBlend(col, pcol);
133 }
134 }
135
136 return col.xyz*col.w;
137 }
138
139 vec3 postProcess(vec3 col, vec2 q) {
140 col=pow(clamp(col,0.0,1.0),vec3(0.75));
141 col=col*0.6+0.4*col*col*(3.0-2.0*col);
142 col=mix(col, vec3(dot(col, vec3(0.33))), -0.4);
143 col*=0.5+0.5*pow(19.0*q.x*q.y*(1.0-q.x)*(1.0-q.y),0.7);
144 return col;
145 }
146
147 vec3 effect(vec2 p, vec2 q) {
148 float tm = TIME*0.65;
149
150 vec3 ro = offset(tm);
151 vec3 dro = doffset(tm);
152 vec3 ddro = ddoffset(tm);
153
154 vec3 ww = normalize(dro);
155 vec3 uu = normalize(cross(vec3(0.0,1.0,0.0)+1.5*ddro, ww));
156 vec3 vv = normalize(cross(ww, uu));
157
158 vec3 col = color(ww, uu, vv, ro, p);
159 col = postProcess(col, q);
160
161 const float fadeIn = 2.0;
162
163 return col*smoothstep(0.0, fadeIn, TIME);
164 }
165
166 void mainImage(out vec4 fragColor, vec2 fragCoord) {
167 vec2 q = fragCoord/RESOLUTION.xy;
168 vec2 p = -1. + 2. * q;
169 p.x *= RESOLUTION.x/RESOLUTION.y;
170
171 vec3 col = effect(p, q);
172
173 fragColor = vec4(col, 1.0);
174 }