summaryrefslogtreecommitdiff
path: root/src/gpu
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-17 01:48:48 -0300
committerGabriel Schneider <[email protected]>2026-11-17 12:15:01 -0300
commit43151809dac7041bd04bb5181abf7f1182ffea7f (patch)
tree7a81f64c72683cc8b88c3a371dc17d18d23b499e /src/gpu
parent1cb36ee39a8bbc2cf61c28003670d760841d6d3e (diff)
downloadsketchbook-43151809dac7041bd04bb5181abf7f1182ffea7f.tar.gz
sketchbook-43151809dac7041bd04bb5181abf7f1182ffea7f.zip
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.
Diffstat (limited to 'src/gpu')
-rw-r--r--src/gpu/Cells.zig181
-rw-r--r--src/gpu/shaders/decor.frag.glsl26
-rw-r--r--src/gpu/shaders/image.frag.glsl17
-rw-r--r--src/gpu/shaders/image.vert.glsl33
-rw-r--r--src/gpu/shaders/overlay.frag.glsl17
-rw-r--r--src/gpu/shaders/overlay.vert.glsl11
-rw-r--r--src/gpu/shaders/prebuilt/decor.frag.spvbin0 -> 2176 bytes
-rw-r--r--src/gpu/shaders/prebuilt/image.frag.spvbin0 -> 1344 bytes
-rw-r--r--src/gpu/shaders/prebuilt/image.vert.spvbin0 -> 3152 bytes
-rw-r--r--src/gpu/shaders/prebuilt/overlay.frag.spvbin0 -> 1008 bytes
-rw-r--r--src/gpu/shaders/prebuilt/overlay.vert.spvbin0 -> 1040 bytes
-rw-r--r--src/gpu/shaders/prebuilt/ui.frag.spvbin0 -> 3184 bytes
-rw-r--r--src/gpu/shaders/prebuilt/ui.vert.spvbin0 -> 3848 bytes
-rw-r--r--src/gpu/shaders/ui.frag.glsl39
-rw-r--r--src/gpu/shaders/ui.vert.glsl53
15 files changed, 377 insertions, 0 deletions
diff --git a/src/gpu/Cells.zig b/src/gpu/Cells.zig
new file mode 100644
index 0000000..78d7f22
--- /dev/null
+++ b/src/gpu/Cells.zig
@@ -0,0 +1,181 @@
+//! pardes's cell renderer on SDL_GPU, part 1: the shaders' instance ABI
+//! (src/gpu/shaders/*.glsl), the pipelines over it and the resource helpers,
+//! moved from pardes's gui.zig as they were. `c` is the embedder's own SDL
+//! translation (pardes's: SDL3 and font.h), so the embedder's SDL is the one
+//! linked.
+const std = @import("std");
+const c = @import("c");
+
+pub const CellInstance = extern struct {
+ x0: f32,
+ y0: f32,
+ x1: f32,
+ y1: f32,
+ u0: f32,
+ v0: f32,
+ u1: f32,
+ v1: f32,
+ fr: f32,
+ fg: f32,
+ fb: f32,
+ br: f32,
+ bg: f32,
+ bb: f32,
+ /// The flags (the high bits, ui.vert.glsl).
+ effect: u32 = 0,
+ /// A clip rectangle in target pixels; x1 < x0 is none (ui.vert.glsl).
+ clip_x0: f32 = 0,
+ clip_y0: f32 = 0,
+ clip_x1: f32 = -1,
+ clip_y1: f32 = -1,
+};
+
+pub const OverlayVertex = extern struct {
+ x: f32,
+ y: f32,
+ r: f32,
+ g: f32,
+ b: f32,
+ a: f32,
+};
+
+pub const ImageInstance = extern struct {
+ x0: f32,
+ y0: f32,
+ x1: f32,
+ y1: f32,
+ u0: f32,
+ v0: f32,
+ u1: f32,
+ v1: f32,
+};
+
+pub const opaque_bg_bit: u32 = 0x2000_0000;
+
+/// A vertex buffer and its upload buffer holding at least `needed`
+/// elements of `stride` bytes: those there when they do, else twice as
+/// many again until they would (the old ones let go).
+pub fn growInstances(device: *c.SDL_GPUDevice, buffer: *?*c.SDL_GPUBuffer, transfer: *?*c.SDL_GPUTransferBuffer, capacity: *u32, needed: u32, stride: u32) !void {
+ if (needed <= capacity.* and buffer.* != null and transfer.* != null) return;
+ var grown = @max(@as(u32, 1), capacity.*);
+ while (grown < needed) grown = std.math.mul(u32, grown, 2) catch return error.GpuCapacity;
+ const size = std.math.mul(u32, grown, stride) catch return error.GpuCapacity;
+ var vb_info = c.SDL_GPUBufferCreateInfo{ .usage = c.SDL_GPU_BUFFERUSAGE_VERTEX, .size = size, .props = 0 };
+ const next_buffer = c.SDL_CreateGPUBuffer(device, &vb_info) orelse return error.GpuCreate;
+ errdefer c.SDL_ReleaseGPUBuffer(device, next_buffer);
+ var xf_info = c.SDL_GPUTransferBufferCreateInfo{ .usage = c.SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD, .size = size, .props = 0 };
+ const next_transfer = c.SDL_CreateGPUTransferBuffer(device, &xf_info) orelse return error.GpuCreate;
+ if (buffer.*) |old| c.SDL_ReleaseGPUBuffer(device, old);
+ if (transfer.*) |old| c.SDL_ReleaseGPUTransferBuffer(device, old);
+ buffer.* = next_buffer;
+ transfer.* = next_transfer;
+ capacity.* = grown;
+}
+
+/// One vertex buffer of a pipeline: `pitch` bytes an element, read per
+/// vertex or per instance through `attrs`.
+pub const VertexInput = struct { pitch: u32, rate: c.SDL_GPUVertexInputRate, attrs: []const c.SDL_GPUVertexAttribute };
+
+/// The cells' and the decor's instances (ui.vert.glsl).
+pub const cell_input: VertexInput = .{ .pitch = @sizeOf(CellInstance), .rate = c.SDL_GPU_VERTEXINPUTRATE_INSTANCE, .attrs = &.{
+ .{ .location = 0, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4, .offset = @offsetOf(CellInstance, "x0") },
+ .{ .location = 1, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4, .offset = @offsetOf(CellInstance, "u0") },
+ .{ .location = 2, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT3, .offset = @offsetOf(CellInstance, "fr") },
+ .{ .location = 3, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT3, .offset = @offsetOf(CellInstance, "br") },
+ .{ .location = 4, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_UINT, .offset = @offsetOf(CellInstance, "effect") },
+ .{ .location = 5, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4, .offset = @offsetOf(CellInstance, "clip_x0") },
+} };
+
+pub const overlay_input: VertexInput = .{ .pitch = @sizeOf(OverlayVertex), .rate = c.SDL_GPU_VERTEXINPUTRATE_VERTEX, .attrs = &.{
+ .{ .location = 0, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT2, .offset = @offsetOf(OverlayVertex, "x") },
+ .{ .location = 1, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4, .offset = @offsetOf(OverlayVertex, "r") },
+} };
+
+pub const image_input: VertexInput = .{ .pitch = @sizeOf(ImageInstance), .rate = c.SDL_GPU_VERTEXINPUTRATE_INSTANCE, .attrs = &.{
+ .{ .location = 0, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4, .offset = @offsetOf(ImageInstance, "x0") },
+ .{ .location = 1, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4, .offset = @offsetOf(ImageInstance, "u0") },
+} };
+
+/// A pipeline drawing triangles into `color_format`: `vert`, and `frag`
+/// with its samplers and uniform buffers, over one vertex buffer of
+/// `input` (none: the post chain's triangle over the whole frame).
+pub fn makePipeline(
+ device: *c.SDL_GPUDevice,
+ color_format: c.SDL_GPUTextureFormat,
+ vert: []const u8,
+ frag: []const u8,
+ samplers: u32,
+ uniforms: u32,
+ input: ?VertexInput,
+ blend: c.SDL_GPUColorTargetBlendState,
+) !*c.SDL_GPUGraphicsPipeline {
+ const vs = try makeShader(device, vert, c.SDL_GPU_SHADERSTAGE_VERTEX, 0, 0);
+ defer c.SDL_ReleaseGPUShader(device, vs);
+ const fs = try makeShader(device, frag, c.SDL_GPU_SHADERSTAGE_FRAGMENT, samplers, uniforms);
+ defer c.SDL_ReleaseGPUShader(device, fs);
+ var col_desc = c.SDL_GPUColorTargetDescription{ .format = color_format, .blend_state = blend };
+ var vbuf_desc: c.SDL_GPUVertexBufferDescription = undefined;
+ var info = std.mem.zeroes(c.SDL_GPUGraphicsPipelineCreateInfo);
+ info.vertex_shader = vs;
+ info.fragment_shader = fs;
+ info.primitive_type = c.SDL_GPU_PRIMITIVETYPE_TRIANGLELIST;
+ if (input) |in| {
+ vbuf_desc = .{ .slot = 0, .pitch = in.pitch, .input_rate = in.rate, .instance_step_rate = 0 };
+ info.vertex_input_state = .{
+ .vertex_buffer_descriptions = &vbuf_desc,
+ .num_vertex_buffers = 1,
+ .vertex_attributes = in.attrs.ptr,
+ .num_vertex_attributes = @intCast(in.attrs.len),
+ };
+ }
+ info.rasterizer_state.fill_mode = c.SDL_GPU_FILLMODE_FILL;
+ info.rasterizer_state.cull_mode = c.SDL_GPU_CULLMODE_NONE;
+ info.multisample_state.sample_count = c.SDL_GPU_SAMPLECOUNT_1;
+ info.target_info = .{ .color_target_descriptions = &col_desc, .num_color_targets = 1 };
+ return c.SDL_CreateGPUGraphicsPipeline(device, &info) orelse error.GpuCreate;
+}
+
+pub fn backgroundLayerBlend() c.SDL_GPUColorTargetBlendState {
+ var blend = std.mem.zeroes(c.SDL_GPUColorTargetBlendState);
+ blend.src_color_blendfactor = c.SDL_GPU_BLENDFACTOR_SRC_ALPHA;
+ blend.dst_color_blendfactor = c.SDL_GPU_BLENDFACTOR_ONE_MINUS_SRC_ALPHA;
+ blend.color_blend_op = c.SDL_GPU_BLENDOP_ADD;
+ blend.src_alpha_blendfactor = c.SDL_GPU_BLENDFACTOR_CONSTANT_COLOR;
+ blend.dst_alpha_blendfactor = c.SDL_GPU_BLENDFACTOR_ONE_MINUS_SRC_ALPHA;
+ blend.alpha_blend_op = c.SDL_GPU_BLENDOP_ADD;
+ blend.enable_blend = true;
+ return blend;
+}
+
+fn makeShader(device: *c.SDL_GPUDevice, code: []const u8, stage: c.SDL_GPUShaderStage, n_samplers: u32, n_uniform_buffers: u32) !*c.SDL_GPUShader {
+ var info = std.mem.zeroes(c.SDL_GPUShaderCreateInfo);
+ info.code = code.ptr;
+ info.code_size = code.len;
+ info.entrypoint = "main";
+ info.format = c.SDL_GPU_SHADERFORMAT_SPIRV;
+ info.stage = stage;
+ info.num_samplers = n_samplers;
+ info.num_uniform_buffers = n_uniform_buffers;
+ return c.SDL_CreateGPUShader(device, &info) orelse error.GpuCreate;
+}
+
+/// A 2D texture of one level, one layer and one sample.
+pub fn texture2d(device: *c.SDL_GPUDevice, format: c.SDL_GPUTextureFormat, usage: c.SDL_GPUTextureUsageFlags, width: u32, height: u32) ?*c.SDL_GPUTexture {
+ var info = std.mem.zeroes(c.SDL_GPUTextureCreateInfo);
+ info.type = c.SDL_GPU_TEXTURETYPE_2D;
+ info.format = format;
+ info.usage = usage;
+ info.width = width;
+ info.height = height;
+ info.layer_count_or_depth = 1;
+ info.num_levels = 1;
+ info.sample_count = c.SDL_GPU_SAMPLECOUNT_1;
+ return c.SDL_CreateGPUTexture(device, &info);
+}
+
+test "the shader instance ABI: the flags after the colours, the clip after them" {
+ try std.testing.expectEqual(@as(usize, 76), @sizeOf(CellInstance));
+ try std.testing.expectEqual(@as(usize, 56), @offsetOf(CellInstance, "effect"));
+ try std.testing.expectEqual(@as(usize, 60), @offsetOf(CellInstance, "clip_x0"));
+ try std.testing.expectEqual(@as(usize, 32), @sizeOf(ImageInstance));
+}
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
--- /dev/null
+++ b/src/gpu/shaders/prebuilt/decor.frag.spv
Binary files 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
--- /dev/null
+++ b/src/gpu/shaders/prebuilt/image.frag.spv
Binary files 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
--- /dev/null
+++ b/src/gpu/shaders/prebuilt/image.vert.spv
Binary files 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
--- /dev/null
+++ b/src/gpu/shaders/prebuilt/overlay.frag.spv
Binary files 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
--- /dev/null
+++ b/src/gpu/shaders/prebuilt/overlay.vert.spv
Binary files 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
--- /dev/null
+++ b/src/gpu/shaders/prebuilt/ui.frag.spv
Binary files 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
--- /dev/null
+++ b/src/gpu/shaders/prebuilt/ui.vert.spv
Binary files 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);
+}