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
127
128
129
130
131
132
133
|
#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;
};
// ghostty's one block, cut in three: SDL GPU binds at most 4 KiB of a
// uniform block (Vulkan), and the palette alone is 4 KiB. The names and
// their order are ghostty's; each block is a slice of the same memory.
layout(set = 3, binding = 1, std140) uniform Palette {
uniform vec3 iPalette[256];
};
layout(set = 3, binding = 2, std140) uniform Colors {
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; pardesScale
// is the display's density (2 on a 2x screen), for a pass whose pattern is
// in logical pixels. iResolution, fragCoord and iMouse stay in the display's
// pixels, as ghostty's do. pardesCap is the most a bundled pass may do on
// this theme and still leave its text, and its selection's, at their own
// contrast or 4.5 (docs/effects.md); pardesSpare holds pardesSpareCount
// rectangles (x0, y0, x1, y1 in fragCoord's pixels) a bundled pass leaves
// alone: every tag, grip and notice, and the cursor, so no pass ever touches
// a focus indicator.
layout(set = 3, binding = 3, std140) uniform PardesPost {
float pardesOpaque;
float pardesLevel;
float pardesScale;
float pardesCap;
float pardesSpareCount;
vec4 pardesSpare[32];
};
bool pardesSpared(vec2 p) {
for (int i = 0; i < int(pardesSpareCount); i++) {
vec4 r = pardesSpare[i];
if (p.x >= r.x && p.y >= r.y && p.x < r.z && p.y < r.w) return true;
}
return false;
}
// 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
// Grain: the page's own ground takes a fine, still grain, like paper. Only
// pixels of the page's colour (iBackgroundColor) are grained: no glyph, no
// selection, no tag or rule, and nothing in pardesSpare. The grain averages
// to the page, is a logical pixel big (pardesScale), and never moves, so it
// costs no frames. At most 1.5, 3 and 5 of 255 at levels 1 to 3, and never
// more than pardesCap, which keeps the text on it at its own contrast or 4.5.
// It is a Shadertoy file: pardes puts its prefix before it.
float amplitude() { return min(pardesByLevel(1.5, 3.0, 5.0) / 255.0, pardesCap); }
// An integer hash of the grain cell: white, with no pattern to see.
float hash(uvec2 p) {
uint h = p.x * 1664525u + p.y * 1013904223u;
h ^= h >> 16;
h *= 2246822519u;
h ^= h >> 13;
h *= 3266489917u;
h ^= h >> 16;
return float(h) / 4294967295.0;
}
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
vec2 uv = fragCoord / iResolution.xy;
vec4 frame = texture(iChannel0, uv);
fragColor = frame;
vec3 page = iBackgroundColor.rgb;
if (any(greaterThan(abs(frame.rgb - page), vec3(0.75 / 255.0))) || pardesSpared(fragCoord)) return;
uvec2 cell = uvec2(fragCoord / max(1.0, pardesScale));
// Two hashes summed: a triangular spread, softer than a flat one.
float n = hash(cell) + hash(cell + uvec2(7919u, 104729u)) - 1.0;
fragColor = vec4(clamp(page + n * amplitude(), 0.0, 1.0), frame.a);
}
|
