init

ghostty-shaders/warping.glsl

@@ -0,0 +1,108 @@
+#define BLACK_BLEND_THRESHOLD .4 // This is controls the dim of the screen
+const mat2 m = mat2(0.80, 0.60, -0.60, 0.80);
+
+float noise(in vec2 p)
+{
+    return sin(p.x) * sin(p.y);
+}
+
+float fbm4(vec2 p)
+{
+    float f = 0.0;
+    f += 0.5000 * noise(p);
+    p = m * p * 2.02;
+    f += 0.2500 * noise(p);
+    p = m * p * 2.03;
+    f += 0.1250 * noise(p);
+    p = m * p * 2.01;
+    f += 0.0625 * noise(p);
+    return f / 0.9375;
+}
+
+float fbm6(vec2 p)
+{
+    float f = 0.0;
+    f += 0.500000 * (0.5 + 0.5 * noise(p));
+    p = m * p * 2.02;
+    f += 0.250000 * (0.5 + 0.5 * noise(p));
+    p = m * p * 2.03;
+    f += 0.125000 * (0.5 + 0.5 * noise(p));
+    p = m * p * 2.01;
+    f += 0.062500 * (0.5 + 0.5 * noise(p));
+    p = m * p * 2.04;
+    f += 0.031250 * (0.5 + 0.5 * noise(p));
+    p = m * p * 2.01;
+    f += 0.015625 * (0.5 + 0.5 * noise(p));
+    return f / 0.96875;
+}
+
+vec2 fbm4_2(vec2 p)
+{
+    return vec2(fbm4(p), fbm4(p + vec2(7.8)));
+}
+
+vec2 fbm6_2(vec2 p)
+{
+    return vec2(fbm6(p + vec2(16.8)), fbm6(p + vec2(11.5)));
+}
+
+//====================================================================
+
+float func(vec2 q, out vec4 ron)
+{
+    q += 0.03 * sin(vec2(0.27, 0.23) * iTime + length(q) * vec2(4.1, 4.3));
+
+    vec2 o = fbm4_2(0.9 * q);
+
+    o += 0.04 * sin(vec2(0.12, 0.14) * iTime + length(o));
+
+    vec2 n = fbm6_2(3.0 * o);
+
+    ron = vec4(o, n);
+
+    float f = 0.5 + 0.5 * fbm4(1.8 * q + 6.0 * n);
+
+    return mix(f, f * f * f * 3.5, f * abs(n.x));
+}
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord)
+{
+    vec2 p = (2.0 * fragCoord - iResolution.xy) / iResolution.y;
+    float e = 2.0 / iResolution.y;
+
+    vec4 on = vec4(0.0);
+    float f = func(p, on);
+
+    vec3 col = vec3(0.0);
+    col = mix(vec3(0.2, 0.1, 0.4), vec3(0.3, 0.05, 0.05), f);
+    col = mix(col, vec3(0.9, 0.9, 0.9), dot(on.zw, on.zw));
+    col = mix(col, vec3(0.4, 0.3, 0.3), 0.2 + 0.5 * on.y * on.y);
+    col = mix(col, vec3(0.0, 0.2, 0.4), 0.5 * smoothstep(1.2, 1.3, abs(on.z) + abs(on.w)));
+    col = clamp(col * f * 2.0, 0.0, 1.0);
+
+    #if 0
+    // gpu derivatives - bad quality, but fast
+    vec3 nor = normalize(vec3(dFdx(f) * iResolution.x, 6.0, dFdy(f) * iResolution.y));
+    #else
+    // manual derivatives - better quality, but slower
+    vec4 kk;
+    vec3 nor = normalize(vec3(func(p + vec2(e, 0.0), kk) - f,
+                2.0 * e,
+                func(p + vec2(0.0, e), kk) - f));
+    #endif
+
+    vec3 lig = normalize(vec3(0.9, 0.2, -0.4));
+    float dif = clamp(0.3 + 0.7 * dot(nor, lig), 0.0, 1.0);
+    vec3 lin = vec3(0.70, 0.90, 0.95) * (nor.y * 0.5 + 0.5) + vec3(0.15, 0.10, 0.05) * dif;
+    col *= 1.2 * lin;
+    col = 1.0 - col;
+    col = 1.1 * col * col;
+
+    vec2 termUV = fragCoord.xy / iResolution.xy;
+    vec4 terminalColor = texture(iChannel0, termUV);
+    //
+    float alpha = step(length(terminalColor.rgb), BLACK_BLEND_THRESHOLD);
+    vec3 blendedColor = mix(terminalColor.rgb * 1.0, col.rgb * 0.3, alpha);
+    //
+    fragColor = vec4(blendedColor, terminalColor.a);
+}