From 43151809dac7041bd04bb5181abf7f1182ffea7f Mon Sep 17 00:00:00 2001 From: Gabriel Schneider Date: Tue, 17 Nov 2026 01:48:48 -0300 Subject: Add pardes's cell shaders, instance ABI and GPU resource helpers Moved verbatim from pardes's src/gui/gui.zig (step S1 of moving its renderer here): the seven GLSL shaders and their committed SPIR-V under src/gpu/shaders/, and src/gpu/Cells.zig with the instance structs the shaders read, the vertex inputs, makePipeline, the layer blend, texture2d and growInstances (which takes the device instead of pardes's Gui). Cells.zig imports the embedder's own SDL translation as `c`; pardes compiles it from this checkout. `zig build shaders` refreshes the prebuilt SPIR-V. --- src/gpu/shaders/decor.frag.glsl | 26 +++++++++++++++ src/gpu/shaders/image.frag.glsl | 17 ++++++++++ src/gpu/shaders/image.vert.glsl | 33 +++++++++++++++++++ src/gpu/shaders/overlay.frag.glsl | 17 ++++++++++ src/gpu/shaders/overlay.vert.glsl | 11 +++++++ src/gpu/shaders/prebuilt/decor.frag.spv | Bin 0 -> 2176 bytes src/gpu/shaders/prebuilt/image.frag.spv | Bin 0 -> 1344 bytes src/gpu/shaders/prebuilt/image.vert.spv | Bin 0 -> 3152 bytes src/gpu/shaders/prebuilt/overlay.frag.spv | Bin 0 -> 1008 bytes src/gpu/shaders/prebuilt/overlay.vert.spv | Bin 0 -> 1040 bytes src/gpu/shaders/prebuilt/ui.frag.spv | Bin 0 -> 3184 bytes src/gpu/shaders/prebuilt/ui.vert.spv | Bin 0 -> 3848 bytes src/gpu/shaders/ui.frag.glsl | 39 ++++++++++++++++++++++ src/gpu/shaders/ui.vert.glsl | 53 ++++++++++++++++++++++++++++++ 14 files changed, 196 insertions(+) create mode 100644 src/gpu/shaders/decor.frag.glsl create mode 100644 src/gpu/shaders/image.frag.glsl create mode 100644 src/gpu/shaders/image.vert.glsl create mode 100644 src/gpu/shaders/overlay.frag.glsl create mode 100644 src/gpu/shaders/overlay.vert.glsl create mode 100644 src/gpu/shaders/prebuilt/decor.frag.spv create mode 100644 src/gpu/shaders/prebuilt/image.frag.spv create mode 100644 src/gpu/shaders/prebuilt/image.vert.spv create mode 100644 src/gpu/shaders/prebuilt/overlay.frag.spv create mode 100644 src/gpu/shaders/prebuilt/overlay.vert.spv create mode 100644 src/gpu/shaders/prebuilt/ui.frag.spv create mode 100644 src/gpu/shaders/prebuilt/ui.vert.spv create mode 100644 src/gpu/shaders/ui.frag.glsl create mode 100644 src/gpu/shaders/ui.vert.glsl (limited to 'src/gpu/shaders') diff --git a/src/gpu/shaders/decor.frag.glsl b/src/gpu/shaders/decor.frag.glsl new file mode 100644 index 0000000..71bb12e --- /dev/null +++ b/src/gpu/shaders/decor.frag.glsl @@ -0,0 +1,26 @@ +#version 450 + +// Decor, drawn by ui.vert.glsl like a cell, and blended as the overlay +// pipeline blends (backgroundLayerBlend). Ink (a cursor) is drawn with the +// opacity uniform at 1. +// +// A hard-edged fill (a rule, a rail, a grip mark, a bar cursor): its colour +// rides in the cell's ground (a_bg), its coverage in a_fg.r, so the result +// is the overlay pipeline's exactly. + +layout(std140, set = 3, binding = 0) uniform UiUniforms { + float background_opacity; +} u_ui; + +layout(location = 1) in vec3 v_fg; +layout(location = 2) in vec3 v_bg; +layout(location = 5) flat in vec4 v_clip; + +layout(location = 0) out vec4 o_col; + +void main() { + if (v_clip.z >= v_clip.x && (gl_FragCoord.x < v_clip.x || gl_FragCoord.x >= v_clip.z || + gl_FragCoord.y < v_clip.y || gl_FragCoord.y >= v_clip.w)) discard; + float opacity = clamp(u_ui.background_opacity, 0.0, 1.0); + o_col = vec4(v_bg * opacity, v_fg.r); +} diff --git a/src/gpu/shaders/image.frag.glsl b/src/gpu/shaders/image.frag.glsl new file mode 100644 index 0000000..38a95da --- /dev/null +++ b/src/gpu/shaders/image.frag.glsl @@ -0,0 +1,17 @@ +#version 450 + +layout(set = 2, binding = 0) uniform sampler2D u_image; +layout(std140, set = 3, binding = 0) uniform UiUniforms { + float background_opacity; +} u_ui; + +layout(location = 0) in vec2 v_uv; +layout(location = 0) out vec4 o_col; + +void main() { + vec4 source = texture(u_image, v_uv); + // Keep source coverage for destination subtraction; the pipeline scales + // source alpha by the same opacity through its alpha blend constant. + source.rgb *= clamp(u_ui.background_opacity, 0.0, 1.0); + o_col = source; +} diff --git a/src/gpu/shaders/image.vert.glsl b/src/gpu/shaders/image.vert.glsl new file mode 100644 index 0000000..ace55a5 --- /dev/null +++ b/src/gpu/shaders/image.vert.glsl @@ -0,0 +1,33 @@ +#version 450 + +// One instance per Surface image attachment. The CPU has already converted +// the pane's cell rectangle and the aspect-preserving contain fit to NDC. +layout(location = 0) in vec4 a_rect; // x0, y0, x1, y1 +layout(location = 1) in vec4 a_uv_rect; // u0, v0, u1, v1 + +layout(location = 0) out vec2 v_uv; + +void main() { + vec2 pos; + int corner = gl_VertexIndex % 6; + if (corner == 0) { + pos = vec2(a_rect.x, a_rect.y); + v_uv = vec2(a_uv_rect.x, a_uv_rect.y); + } else if (corner == 1) { + pos = vec2(a_rect.z, a_rect.y); + v_uv = vec2(a_uv_rect.z, a_uv_rect.y); + } else if (corner == 2) { + pos = vec2(a_rect.z, a_rect.w); + v_uv = vec2(a_uv_rect.z, a_uv_rect.w); + } else if (corner == 3) { + pos = vec2(a_rect.x, a_rect.y); + v_uv = vec2(a_uv_rect.x, a_uv_rect.y); + } else if (corner == 4) { + pos = vec2(a_rect.z, a_rect.w); + v_uv = vec2(a_uv_rect.z, a_uv_rect.w); + } else { + pos = vec2(a_rect.x, a_rect.w); + v_uv = vec2(a_uv_rect.x, a_uv_rect.w); + } + gl_Position = vec4(pos, 0.0, 1.0); +} diff --git a/src/gpu/shaders/overlay.frag.glsl b/src/gpu/shaders/overlay.frag.glsl new file mode 100644 index 0000000..b5ac8d5 --- /dev/null +++ b/src/gpu/shaders/overlay.frag.glsl @@ -0,0 +1,17 @@ +#version 450 + +layout(std140, set = 3, binding = 0) uniform UiUniforms { + float background_opacity; +} u_ui; + +layout(location = 0) in vec4 v_color; + +layout(location = 0) out vec4 o_col; + +void main() { + // Preserve shape coverage for destination subtraction. The pipeline uses + // the matching opacity blend constant for source alpha, so graphics laid + // over a background with the same opacity do not accumulate opaque seams. + // Text/cursor draw groups bind opacity 1 instead. + o_col = vec4(v_color.rgb * clamp(u_ui.background_opacity, 0.0, 1.0), v_color.a); +} diff --git a/src/gpu/shaders/overlay.vert.glsl b/src/gpu/shaders/overlay.vert.glsl new file mode 100644 index 0000000..5f6be59 --- /dev/null +++ b/src/gpu/shaders/overlay.vert.glsl @@ -0,0 +1,11 @@ +#version 450 + +layout(location = 0) in vec2 a_pos; +layout(location = 1) in vec4 a_color; + +layout(location = 0) out vec4 v_color; + +void main() { + v_color = a_color; + gl_Position = vec4(a_pos, 0.0, 1.0); +} diff --git a/src/gpu/shaders/prebuilt/decor.frag.spv b/src/gpu/shaders/prebuilt/decor.frag.spv new file mode 100644 index 0000000..0d5af9d Binary files /dev/null and b/src/gpu/shaders/prebuilt/decor.frag.spv differ diff --git a/src/gpu/shaders/prebuilt/image.frag.spv b/src/gpu/shaders/prebuilt/image.frag.spv new file mode 100644 index 0000000..d663ed8 Binary files /dev/null and b/src/gpu/shaders/prebuilt/image.frag.spv differ diff --git a/src/gpu/shaders/prebuilt/image.vert.spv b/src/gpu/shaders/prebuilt/image.vert.spv new file mode 100644 index 0000000..1105bae Binary files /dev/null and b/src/gpu/shaders/prebuilt/image.vert.spv differ diff --git a/src/gpu/shaders/prebuilt/overlay.frag.spv b/src/gpu/shaders/prebuilt/overlay.frag.spv new file mode 100644 index 0000000..e296e99 Binary files /dev/null and b/src/gpu/shaders/prebuilt/overlay.frag.spv differ diff --git a/src/gpu/shaders/prebuilt/overlay.vert.spv b/src/gpu/shaders/prebuilt/overlay.vert.spv new file mode 100644 index 0000000..a518c57 Binary files /dev/null and b/src/gpu/shaders/prebuilt/overlay.vert.spv differ diff --git a/src/gpu/shaders/prebuilt/ui.frag.spv b/src/gpu/shaders/prebuilt/ui.frag.spv new file mode 100644 index 0000000..91022fe Binary files /dev/null and b/src/gpu/shaders/prebuilt/ui.frag.spv differ diff --git a/src/gpu/shaders/prebuilt/ui.vert.spv b/src/gpu/shaders/prebuilt/ui.vert.spv new file mode 100644 index 0000000..ad132bf Binary files /dev/null and b/src/gpu/shaders/prebuilt/ui.vert.spv differ diff --git a/src/gpu/shaders/ui.frag.glsl b/src/gpu/shaders/ui.frag.glsl new file mode 100644 index 0000000..7f70629 --- /dev/null +++ b/src/gpu/shaders/ui.frag.glsl @@ -0,0 +1,39 @@ +#version 450 + +// Sample the glyph atlas (R = coverage 0..1) and mix the cell's bg up to its fg +// by that coverage. Output is PREMULTIPLIED: an opaque cell is unchanged. +// WindowOpacity changes only the ground's coverage, never the glyph's ink. + +layout(set = 2, binding = 0) uniform sampler2D u_atlas; +layout(std140, set = 3, binding = 0) uniform UiUniforms { + float background_opacity; +} u_ui; + +layout(location = 0) in vec2 v_uv; +layout(location = 1) in vec3 v_fg; +layout(location = 2) in vec3 v_bg; +layout(location = 4) flat in uint v_effect; +layout(location = 5) flat in vec4 v_clip; + +layout(location = 0) out vec4 o_col; + +void main() { + if (v_clip.z >= v_clip.x && (gl_FragCoord.x < v_clip.x || gl_FragCoord.x >= v_clip.z || + gl_FragCoord.y < v_clip.y || gl_FragCoord.y >= v_clip.w)) discard; + float a = texture(u_atlas, v_uv).r; + // A block cursor is foreground chrome even though its fill occupies the + // cell background: keep it visible at WindowOpacity 0. Otherwise the + // ground's coverage is the setting's. The flag is shared with + // ui.vert.glsl and src/gui/gui.zig. + float bgA = (v_effect & 0x20000000u) != 0u ? 1.0 : clamp(u_ui.background_opacity, 0.0, 1.0); + + // Ink over ground, both premultiplied: v_fg*a + (v_bg*bgA)*(1-a), which is + // mix() with the ground already premultiplied. At bgA = 1 that is exactly + // the mix(v_bg, v_fg, a) at alpha 1 this shader always wrote. + vec4 under = vec4(v_bg * bgA, bgA); + vec4 cell = vec4(mix(under.rgb, v_fg, a), mix(under.a, 1.0, a)); + + // FreeType's hinted grayscale bitmap is already the intended coverage. + // Preserve it exactly; weight-changing gamma hacks blur small stems. + o_col = cell; +} diff --git a/src/gpu/shaders/ui.vert.glsl b/src/gpu/shaders/ui.vert.glsl new file mode 100644 index 0000000..e3532e6 --- /dev/null +++ b/src/gpu/shaders/ui.vert.glsl @@ -0,0 +1,53 @@ +#version 450 + +// Terminal cell renderer. The CPU uploads one instance per visible cell; this +// shader expands each instance into a two-triangle quad with gl_VertexIndex. +// The fragment shader mixes fg/bg by the atlas's alpha (a glyph mask in the R +// channel), so background fills and glyph foregrounds draw in a single pass. + +layout(location = 0) in vec4 a_rect; // x0, y0, x1, y1 +layout(location = 1) in vec4 a_uv_rect; // u0, v0, u1, v1 +layout(location = 2) in vec3 a_fg; +layout(location = 3) in vec3 a_bg; +// Flags, the high bits: an opaque block-cursor fill (ui.frag.glsl). +layout(location = 4) in uint a_effect; +// A clip rectangle in target pixels (x0, y0, x1, y1): the fragment shader +// drops what lies outside it. x1 < x0 is none. +layout(location = 5) in vec4 a_clip; + +layout(location = 0) out vec2 v_uv; +layout(location = 1) out vec3 v_fg; +layout(location = 2) out vec3 v_bg; +layout(location = 4) flat out uint v_effect; +layout(location = 5) flat out vec4 v_clip; + +void main() { + vec2 pos; + vec2 uv; + int corner = gl_VertexIndex % 6; + if (corner == 0) { + pos = vec2(a_rect.x, a_rect.y); + uv = vec2(a_uv_rect.x, a_uv_rect.y); + } else if (corner == 1) { + pos = vec2(a_rect.z, a_rect.y); + uv = vec2(a_uv_rect.z, a_uv_rect.y); + } else if (corner == 2) { + pos = vec2(a_rect.z, a_rect.w); + uv = vec2(a_uv_rect.z, a_uv_rect.w); + } else if (corner == 3) { + pos = vec2(a_rect.x, a_rect.y); + uv = vec2(a_uv_rect.x, a_uv_rect.y); + } else if (corner == 4) { + pos = vec2(a_rect.z, a_rect.w); + uv = vec2(a_uv_rect.z, a_uv_rect.w); + } else { + pos = vec2(a_rect.x, a_rect.w); + uv = vec2(a_uv_rect.x, a_uv_rect.w); + } + v_uv = uv; + v_fg = a_fg; + v_bg = a_bg; + v_effect = a_effect; + v_clip = a_clip; + gl_Position = vec4(pos, 0.0, 1.0); +} -- cgit v1.3