1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
#version 450
// pardes's Shadertoy prefix (docs/render-pipeline.md §6), put before every
// post pass: a bundled one in shaders/post/ at build time, a user's file at
// run time. The uniform names, types and std140 order are ghostty 1.3.2's
// (src/renderer/shaders/shadertoy_prefix.glsl), so a shader written for
// ghostty runs here; only the bindings are SDL GPU's (a fragment shader's
// textures in set 2, its uniform blocks in set 3). Y is down everywhere, as
// on ghostty's Metal renderer: fragCoord, iChannel0's uv and the cursor
// rectangles share one top-left space, and iCurrentCursor is (left x,
// BOTTOM-edge y, width, height) in framebuffer pixels.
layout(set = 3, binding = 0, std140) uniform Globals {
uniform vec3 iResolution;
uniform float iTime;
uniform float iTimeDelta;
uniform float iFrameRate;
uniform int iFrame;
uniform float iChannelTime[4];
uniform vec3 iChannelResolution[4];
uniform vec4 iMouse;
uniform vec4 iDate;
uniform float iSampleRate;
uniform vec4 iCurrentCursor;
uniform vec4 iPreviousCursor;
uniform vec4 iCurrentCursorColor;
uniform vec4 iPreviousCursorColor;
uniform int iCurrentCursorStyle;
uniform int iPreviousCursorStyle;
uniform int iCursorVisible;
uniform float iTimeCursorChange;
uniform float iTimeFocus;
uniform int iFocus;
uniform vec3 iPalette[256];
uniform vec3 iBackgroundColor;
uniform vec3 iForegroundColor;
uniform vec3 iCursorColor;
uniform vec3 iCursorText;
uniform vec3 iSelectionForegroundColor;
uniform vec3 iSelectionBackgroundColor;
};
// pardes's own: pardesOpaque is 1 when the window is opaque, so a pass
// cannot punch holes in it through its alpha; pardesLevel is a bundled
// pass's strength, 1 to 3 (`Crt 3`), and 0 for a user's file.
layout(set = 3, binding = 1, std140) uniform PardesPost {
float pardesOpaque;
float pardesLevel;
};
// A bundled pass's constant at levels 1, 2 and 3.
float pardesByLevel(float one, float two, float three) {
return pardesLevel < 1.5 ? one : (pardesLevel < 2.5 ? two : three);
}
#define CURSORSTYLE_BLOCK 0
#define CURSORSTYLE_BLOCK_HOLLOW 1
#define CURSORSTYLE_BAR 2
#define CURSORSTYLE_UNDERLINE 3
#define CURSORSTYLE_LOCK 4
layout(set = 2, binding = 0) uniform sampler2D iChannel0;
layout(location = 0) out vec4 _fragColor;
#define texture2D texture
void mainImage(out vec4 fragColor, in vec2 fragCoord);
void main() {
mainImage(_fragColor, gl_FragCoord.xy);
if (pardesOpaque > 0.5) _fragColor.a = 1.0;
}
// The shader's own lines count from 1, so glslc's errors name them.
#line 1
// Ripple: the page as a still pool a slow swell crosses. Rings travel out
// from the middle of the window at a fixed speed in pixels, so they look
// the same at any size and frame rate; at the default level the displacement
// is at most a couple of pixels, so text stays readable, and it eases in over its first half
// second instead of snapping on. Each ring catches the light a little on its
// rising side, in linear light, and the result is dithered so the shading
// never bands. It is a Shadertoy file: pardes puts its prefix before it.
const float TAU = 6.28318530718;
const float EASE_IN = 0.5; // seconds
// Each at levels 1, 2 and 3 (`Ripple 1`..`Ripple 3`); 2 is the default.
float wavelengthPx() { return pardesByLevel(170.0, 150.0, 120.0); }
float speedPx() { return pardesByLevel(40.0, 55.0, 80.0); } // outward, per second
float amplitudePx() { return pardesByLevel(1.2, 2.2, 5.0); }
float shade() { return pardesByLevel(0.02, 0.035, 0.09); } // light on a slope, linear
float reachEnd() { return pardesByLevel(0.85, 0.95, 1.3); } // how far out it dies away
vec3 toLinear(vec3 c) {
return mix(pow((c + 0.055) / 1.055, vec3(2.4)), c / 12.92, lessThanEqual(c, vec3(0.04045)));
}
vec3 toSrgb(vec3 c) {
c = max(c, vec3(0.0));
return mix(1.055 * pow(c, vec3(1.0 / 2.4)) - 0.055, c * 12.92, lessThanEqual(c, vec3(0.0031308)));
}
float ign(vec2 p) {
return fract(52.9829189 * fract(dot(p, vec2(0.06711056, 0.00583715))));
}
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
vec2 size = iResolution.xy;
vec2 center = 0.5 * size;
vec2 offset = fragCoord - center;
float radius = length(offset);
float reach = 0.5 * length(size);
// Strongest a third of the way out, fading to nothing at the middle
// and at the edges, so the window's frame never wobbles.
float envelope = smoothstep(0.0, 0.18, radius / reach) * (1.0 - smoothstep(0.35, reachEnd(), radius / reach));
float ease = smoothstep(0.0, EASE_IN, iTime);
float phase = (radius - iTime * speedPx()) * TAU / wavelengthPx();
float height = sin(phase);
float slope = cos(phase);
vec2 dir = offset / max(radius, 1e-3);
vec2 moved = fragCoord + dir * height * amplitudePx() * envelope * ease;
vec4 s = texture(iChannel0, moved / size);
vec3 col = toLinear(s.rgb) * (1.0 + shade() * slope * envelope * ease);
vec3 srgb = toSrgb(col) + (ign(fragCoord + float(iFrame % 64) * 5.588238) - 0.5) / 255.0;
fragColor = vec4(clamp(srgb, 0.0, 1.0), s.a);
}
|
