init

ghostty-shaders/cubes.glsl

@@ -0,0 +1,111 @@
+// credits: https://github.com/rymdlego
+
+const float speed = 0.2;
+const float cube_size = 1.0;
+const float cube_brightness = 1.0;
+const float cube_rotation_speed = 2.8;
+const float camera_rotation_speed = 0.1;
+
+mat3 rotationMatrix(vec3 m, float a) {
+    m = normalize(m);
+    float c = cos(a), s = sin(a);
+    return mat3(c + (1. - c) * m.x * m.x,
+        (1. - c) * m.x * m.y - s * m.z,
+        (1. - c) * m.x * m.z + s * m.y,
+        (1. - c) * m.x * m.y + s * m.z,
+        c + (1. - c) * m.y * m.y,
+        (1. - c) * m.y * m.z - s * m.x,
+        (1. - c) * m.x * m.z - s * m.y,
+        (1. - c) * m.y * m.z + s * m.x,
+        c + (1. - c) * m.z * m.z);
+}
+
+float sphere(vec3 pos, float radius)
+{
+    return length(pos) - radius;
+}
+
+float box(vec3 pos, vec3 size)
+{
+    float t = iTime;
+    pos = pos * 0.9 * rotationMatrix(vec3(sin(t / 4.0 * speed) * 10., cos(t / 4.0 * speed) * 12., 2.7), t * 2.4 / 4.0 * speed * cube_rotation_speed);
+    return length(max(abs(pos) - size, 0.0));
+}
+
+float distfunc(vec3 pos)
+{
+    float t = iTime;
+
+    float size = 0.45 + 0.25 * abs(16.0 * sin(t * speed / 4.0));
+    // float size = 2.3 + 1.8*tan((t-5.4)*6.549);
+    size = cube_size * 0.16 * clamp(size, 2.0, 4.0);
+
+    //pos = pos * rotationMatrix(vec3(0.,-3.,0.7), 3.3 * mod(t/30.0, 4.0));
+    vec3 q = mod(pos, 5.0) - 2.5;
+    float obj1 = box(q, vec3(size));
+    return obj1;
+}
+
+void mainImage(out vec4 fragColor, in vec2 fragCoord)
+{
+    float t = iTime;
+    vec2 screenPos = -1.0 + 2.0 * fragCoord.xy / iResolution.xy;
+    screenPos.x *= iResolution.x / iResolution.y;
+    vec3 cameraOrigin = vec3(t * 1.0 * speed, 0.0, 0.0);
+    // vec3 cameraOrigin = vec3(t*1.8*speed, 3.0+t*0.02*speed, 0.0);
+    vec3 cameraTarget = vec3(t * 100., 0.0, 0.0);
+    cameraTarget = vec3(t * 20.0, 0.0, 0.0) * rotationMatrix(vec3(0.0, 0.0, 1.0), t * speed * camera_rotation_speed);
+
+    vec3 upDirection = vec3(0.5, 1.0, 0.6);
+
+    vec3 cameraDir = normalize(cameraTarget - cameraOrigin);
+    vec3 cameraRight = normalize(cross(upDirection, cameraOrigin));
+    vec3 cameraUp = cross(cameraDir, cameraRight);
+
+    vec3 rayDir = normalize(cameraRight * screenPos.x + cameraUp * screenPos.y + cameraDir);
+
+    const int MAX_ITER = 16;
+    const float MAX_DIST = 48.0;
+    const float EPSILON = 0.01;
+
+    float totalDist = 0.0;
+    vec3 pos = cameraOrigin;
+    float dist = EPSILON;
+
+    for (int i = 0; i < MAX_ITER; i++)
+    {
+        if (dist < EPSILON || totalDist > MAX_DIST)
+            break;
+        dist = distfunc(pos);
+        totalDist += dist;
+        pos += dist * rayDir;
+    }
+
+    vec4 cubes;
+
+    if (dist < EPSILON)
+    {
+        // Lighting Code
+        vec2 eps = vec2(0.0, EPSILON);
+        vec3 normal = normalize(vec3(
+                    distfunc(pos + eps.yxx) - distfunc(pos - eps.yxx),
+                    distfunc(pos + eps.xyx) - distfunc(pos - eps.xyx),
+                    distfunc(pos + eps.xxy) - distfunc(pos - eps.xxy)));
+        float diffuse = max(0., dot(-rayDir, normal));
+        float specular = pow(diffuse, 32.0);
+        vec3 color = vec3(diffuse + specular);
+        vec3 cubeColor = vec3(abs(screenPos), 0.5 + 0.5 * sin(t * 2.0)) * 0.8;
+        cubeColor = mix(cubeColor.rgb, vec3(0.0, 0.0, 0.0), 1.0);
+        color += cubeColor;
+        cubes = vec4(color, 1.0) * vec4(1.0 - (totalDist / MAX_DIST));
+        cubes = vec4(cubes.rgb * 0.02 * cube_brightness, 0.1);
+    }
+    else {
+        cubes = vec4(0.0);
+    }
+
+    vec2 uv = fragCoord / iResolution.xy;
+    vec4 terminalColor = texture(iChannel0, uv);
+    vec3 blendedColor = terminalColor.rgb + cubes.rgb;
+    fragColor = vec4(blendedColor, terminalColor.a);
+}