| 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 |
} |