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/Cells.zig | 181 ++++++++++++++++++++++++++++++ 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 +++++++++ 15 files changed, 377 insertions(+) create mode 100644 src/gpu/Cells.zig 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') 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 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 From 6af3c07190e7aec46596e00afb3c6b613c9e02eb Mon Sep 17 00:00:00 2001 From: Gabriel Schneider Date: Tue, 17 Nov 2026 03:05:42 -0300 Subject: Add pardes's font shim and glyph atlas Moved from pardes's src/gui/ (step S2 of moving its renderer here): vendor/font.c and font.h, its FreeType and HarfBuzz shim, byte for byte, and src/font/Atlas.zig, the glyph atlas from gui.zig: the faces (a primary and fallbacks), the 2048x2048 R8 stage filled pen-style, the slot of every glyph drawn, the dirty rows, the hand-drawn box rules, underlines and strikethrough, and the centring of grip glyphs. The key's bits are pardes's. What gui.zig read from its globals and its window (the sizes, a centred glyph's cells, dp(1) for the line thickness) is passed to each cachedGlyph; the frame probe stays in pardes. Atlas.zig imports the embedder's translation of font.h as `c`, and the embedder compiles font.c against its own FreeType and HarfBuzz and exports ui_malloc and friends; the file's own tests (the raster, the rules, the decorations, the dirty rows) export them over C's heap and run from pardes's unit-test. --- src/font/Atlas.zig | 510 +++++++++++++++++++++++++++++++++++++++++++++++++++++ vendor/README.md | 4 + vendor/font.c | 471 +++++++++++++++++++++++++++++++++++++++++++++++++ vendor/font.h | 98 ++++++++++ 4 files changed, 1083 insertions(+) create mode 100644 src/font/Atlas.zig create mode 100644 vendor/font.c create mode 100644 vendor/font.h (limited to 'src') diff --git a/src/font/Atlas.zig b/src/font/Atlas.zig new file mode 100644 index 0000000..d05bff4 --- /dev/null +++ b/src/font/Atlas.zig @@ -0,0 +1,510 @@ +//! pardes's glyph atlas: its faces (a primary and fallbacks over vendor/font.c, +//! FreeType and HarfBuzz), one 2048x2048 R8 stage filled pen-style a cell row +//! at a time, the slot of every glyph drawn, and the rows drawn since the +//! last upload; moved from pardes's gui.zig as it was. CPU only: uploading the +//! rows is the owner's. `c` is the embedder's translation of vendor/font.h, +//! so the embedder's FreeType and HarfBuzz are the ones linked, and the +//! embedder exports ui_malloc and friends (font.h) over its allocator. +//! What a glyph is drawn at (the sizes, a centred glyph's cells, the line +//! thickness) is the caller's, passed to each `cachedGlyph`. +const Atlas = @This(); +const std = @import("std"); +const c = @import("c"); + +pub const atlas_w: u32 = 2048; +pub const atlas_h: u32 = 2048; +pub const Slot = struct { u: u32, v: u32 }; +/// An atlas entry is a glyph of a face (0 the primary font, i the fallback +/// i - 1) at a role's size, drawn `span` cells wide with its own cell `lead` +/// cells in: a ligature is one strip whose cells sample their own slices. +/// Packed, so the atlas map hashes one word instead of walking fields. +pub const Key = packed struct(u64) { + face: u8, + glyph: u32, + role: Role, + decoration: Decoration = .{}, + centered: bool = false, + lead: u4 = 0, + span: u4 = 1, + /// A light box-drawing rule (`ruleArms`), drawn edge to edge rather + /// than from the font; `glyph` is its codepoint. + rule: bool = false, + _: u1 = 0, +}; + +/// The size a glyph is drawn at: the body's, or the tagline's (pardes's +/// FontRole, in its order). +pub const Role = enum(u8) { body, tagline }; +/// pardes's CellStyle.ul, in its order. +pub const Underline = enum(u3) { off, single, double, curly, dotted, dashed }; +pub const Decoration = packed struct(u5) { + bold: bool = false, + underline: Underline = .off, + strikethrough: bool = false, +}; + +/// A role's raster size: the face's pixel size, the width of its cell, the +/// height of its band and its baseline from the band's top. +pub const Size = struct { px: f32, cell_w: u32, height: u32, baseline: i32 }; + +/// The light box-drawing rules drawn by hand, as Ghostty and kitty draw +/// them: a logical pixel thick through the cell's middle, out to its edges, +/// so a markdown table's `|` (Tables.zig) joins the rows above and below it +/// and its delimiter row is one line across, at any line height a font's +/// own glyph would leave gaps in. The arms each one has: left, right, up, down. +pub fn ruleArms(cp: u32) ?[4]bool { + return switch (cp) { + 0x2500 => .{ true, true, false, false }, // ─ + 0x2502 => .{ false, false, true, true }, // │ + 0x250c => .{ false, true, false, true }, // ┌ + 0x2510 => .{ true, false, false, true }, // ┐ + 0x2514 => .{ false, true, true, false }, // └ + 0x2518 => .{ true, false, true, false }, // ┘ + 0x251c => .{ false, true, true, true }, // ├ + 0x2524 => .{ true, false, true, true }, // ┤ + 0x252c => .{ true, true, false, true }, // ┬ + 0x2534 => .{ true, true, true, false }, // ┴ + 0x253c => .{ true, true, true, true }, // ┼ + else => null, + }; +} + +/// `line_px`: the rule's thickness, the caller's logical pixel (pardes: dp(1)). +fn drawRule(out: [*]u8, stride: usize, width: usize, height: usize, arms: [4]bool, line_px: usize) void { + if (width == 0 or height == 0) return; + const t: usize = @min(@max(1, line_px), @min(width, height)); + const mx = (width - t) / 2; + const my = (height - t) / 2; + for (0..height) |y| @memset(out[y * stride ..][0..width], 0); + if (arms[0] or arms[1]) for (0..t) |k| { + const from: usize = if (arms[0]) 0 else mx; + const to: usize = if (arms[1]) width else mx + t; + @memset(out[(my + k) * stride + from ..][0 .. to - from], 255); + }; + if (arms[2] or arms[3]) { + const from: usize = if (arms[2]) 0 else my; + const to: usize = if (arms[3]) height else my + t; + for (from..to) |y| @memset(out[y * stride + mx ..][0..t], 255); + } +} + +pub const InkBounds = struct { min_x: usize, min_y: usize, max_x: usize, max_y: usize }; + +pub fn inkBounds(bitmap: []const u8, stride: usize, w: usize, h: usize) ?InkBounds { + var bounds: ?InkBounds = null; + for (0..h) |y| for (0..w) |x| { + if (bitmap[y * stride + x] == 0) continue; + if (bounds) |*b| { + b.min_x = @min(b.min_x, x); + b.min_y = @min(b.min_y, y); + b.max_x = @max(b.max_x, x); + b.max_y = @max(b.max_y, y); + } else bounds = .{ .min_x = x, .min_y = y, .max_x = x, .max_y = y }; + }; + return bounds; +} + +pub const max_fallbacks = 15; +pub const LoadedFallback = struct { + face: *c.UIFont, + bytes: []u8 = &.{}, +}; + +/// The primary face (Key.face 0) and its bytes, the atlas's when not empty. +font: *c.UIFont, +font_bytes: []u8 = &.{}, +fallbacks: [max_fallbacks]?LoadedFallback = @splat(null), +fallback_count: usize = 0, + +atlas_stage: []u8, +glyphs: std.AutoHashMap(Key, Slot), +pen_x: u32 = 0, +pen_y: u32 = 0, +/// The atlas rows drawn into since the last upload, [top, bottom): the +/// whole atlas at first, since the texture starts undefined. +atlas_dirty_top: u32 = 0, +atlas_dirty_bottom: u32 = atlas_h, +space_slot: Slot = .{ .u = 0, .v = 0 }, + +/// An atlas over the primary face in `bytes`, borrowed for the face's life, +/// its stage cleared; `reset` puts the pen after the space slot. +pub fn init(gpa: std.mem.Allocator, bytes: []const u8) !Atlas { + const font = c.ui_font_new(bytes.ptr, @intCast(bytes.len)) orelse return error.FontInit; + errdefer c.ui_font_free(font); + const atlas_stage = try gpa.alloc(u8, atlas_w * atlas_h); + @memset(atlas_stage, 0); + return .{ .font = font, .atlas_stage = atlas_stage, .glyphs = std.AutoHashMap(Key, Slot).init(gpa) }; +} + +pub fn deinit(a: *Atlas, gpa: std.mem.Allocator) void { + for (a.fallbacks[0..a.fallback_count]) |loaded| { + const fallback = loaded.?; + c.ui_font_free(fallback.face); + if (fallback.bytes.len != 0) gpa.free(fallback.bytes); + } + c.ui_font_free(a.font); + if (a.font_bytes.len != 0) gpa.free(a.font_bytes); + a.glyphs.deinit(); + gpa.free(a.atlas_stage); +} + +/// The primary face from `bytes`, made with `gpa` and now the atlas's +/// (FreeType borrows them for the face lifetime): false, and `bytes` freed, +/// when FreeType refuses them. What was drawn stays until `reset`. +pub fn setFont(a: *Atlas, gpa: std.mem.Allocator, bytes: []u8) bool { + const font = c.ui_font_new(bytes.ptr, @intCast(bytes.len)) orelse { + gpa.free(bytes); + return false; + }; + c.ui_font_free(a.font); + if (a.font_bytes.len != 0) gpa.free(a.font_bytes); + a.font = font; + a.font_bytes = bytes; // FreeType borrows them for the face lifetime + return true; +} + +/// The next fallback face, from `bytes`: borrowed, or the atlas's to free +/// with `gpa` when `owned`. False (owned bytes freed) when FreeType refuses +/// them or every fallback is taken. +pub fn addFallback(a: *Atlas, gpa: std.mem.Allocator, bytes: []const u8, owned: bool) bool { + const len = std.math.cast(c_int, bytes.len); + const face = if (a.fallback_count < a.fallbacks.len and len != null) c.ui_font_new(bytes.ptr, len.?) else null; + if (face == null) { + if (owned) gpa.free(bytes); + return false; + } + a.fallbacks[a.fallback_count] = .{ .face = face.?, .bytes = if (owned) @constCast(bytes) else &.{} }; + a.fallback_count += 1; + return true; +} + +/// HarfBuzz's process-wide objects, made with the primary face (font.h's +/// ui_font_prime): the caller says what allocates them. +pub fn prime(a: *Atlas) void { + c.ui_font_prime(a.font); +} + +/// The primary face's PostScript name, else its family's (font.h). +pub fn fontName(a: *const Atlas) [*c]const u8 { + return c.ui_font_name(a.font); +} + +/// The primary face's cell at `px`: its width, height and ascent (font.h). +pub fn cellMetrics(a: *const Atlas, px: f32, cell_w: *c_int, cell_h: *c_int, ascent: *c_int) void { + c.ui_font_cell_metrics(a.font, px, cell_w, cell_h, ascent); +} + +pub const FaceGlyph = struct { face: u8, glyph: u32 }; + +/// The face and glyph that draw `cp`, the face as a Key face: 0 is the +/// primary font and i the fallback i - 1. A codepoint no face has draws the +/// primary's .notdef. +pub fn glyphForCodepoint(a: *const Atlas, cp: u32) FaceGlyph { + const primary = c.ui_font_glyph(a.font, @intCast(cp)); + if (primary != 0) return .{ .face = 0, .glyph = primary }; + for (a.fallbacks[0..a.fallback_count], 1..) |loaded, face| { + const glyph = c.ui_font_glyph(loaded.?.face, @intCast(cp)); + if (glyph != 0) return .{ .face = @intCast(face), .glyph = glyph }; + } + return .{ .face = 0, .glyph = 0 }; +} + +/// Whether shaping could replace `glyph` of the face `face` (a Key face): +/// font.h's ui_font_substitutes. +pub fn substitutes(a: *const Atlas, face: u8, glyph: u32) bool { + const font = if (face == 0) a.font else a.fallbacks[face - 1].?.face; + return c.ui_font_substitutes(font, glyph) != 0; +} + +/// A run of codepoints all of the face `face`, one cell each, shaped at `px` +/// on a grid `cell_w` wide into `out`: font.h's ui_font_shape. +pub fn shape(a: *const Atlas, face: u8, px: f32, cell_w: u32, cps: []const u32, out: []c.UIShapedCell) void { + const font = if (face == 0) a.font else a.fallbacks[face - 1].?.face; + c.ui_font_shape(font, px, @intCast(cell_w), cps.ptr, @intCast(cps.len), out.ptr); +} + +// The first cell of the cleared atlas stays blank: the space slot, `cell_w` +// wide (the body's). +pub fn reset(a: *Atlas, cell_w: u32) void { + a.glyphs.clearRetainingCapacity(); + @memset(a.atlas_stage, 0); + a.space_slot = .{ .u = 0, .v = 0 }; + a.pen_x = cell_w; + a.pen_y = 0; + a.atlas_dirty_top = 0; + a.atlas_dirty_bottom = atlas_h; +} + +/// The atlas slot of `key`, rasterized on first use at `body`'s or +/// `tagline`'s size (Key.role). A strip is `span` cells wide (a grip glyph +/// `centered_cells` cells, centered); a cell samples its slice of it. Pen +/// rows are `body`'s cell tall. Rules and decorations are `line_px` thick. +/// Null when the atlas is full. +pub fn cachedGlyph(a: *Atlas, key: Key, body: Size, tagline: Size, centered_cells: u32, line_px: usize) ?Slot { + if (a.glyphs.get(key)) |s| return s; + const slot_w = body.cell_w * (if (key.centered) centered_cells else key.span); + if (a.pen_x + slot_w > atlas_w) { + a.pen_x = 0; + a.pen_y += body.height; + } + if (a.pen_y + body.height > atlas_h) return null; // atlas full: fall back + const s = Slot{ .u = a.pen_x, .v = a.pen_y }; + const out = a.atlas_stage.ptr + @as(usize, s.v) * atlas_w + s.u; + const face = if (key.face == 0) a.font else a.fallbacks[key.face - 1].?.face; + const px = if (key.role == .tagline) tagline.px else body.px; + const baseline = if (key.role == .tagline) tagline.baseline else body.baseline; + const cell_w = if (key.role == .tagline) tagline.cell_w else body.cell_w; + const raster_w = if (key.centered) slot_w else cell_w * key.span; + const raster_h = if (key.role == .tagline) tagline.height else body.height; + const bold = @intFromBool(key.decoration.bold); + if (key.rule) { + drawRule(out, atlas_w, raster_w, raster_h, ruleArms(key.glyph).?, line_px); + } else if (key.centered) { + _ = c.ui_font_raster_centered(face, px, key.glyph, bold, out, @intCast(atlas_w), @intCast(raster_w), @intCast(raster_h)); + } else { + _ = c.ui_font_raster(face, px, key.glyph, bold, out, @intCast(atlas_w), @intCast(raster_w), @intCast(raster_h), @intCast(cell_w * key.lead), @intCast(cell_w), baseline); + } + decorateLine(out, atlas_w, raster_w, raster_h, baseline, key.decoration, line_px); + if (key.centered) centerGlyphInk(out, raster_w, raster_h); + a.atlas_dirty_top = @min(a.atlas_dirty_top, s.v); + a.atlas_dirty_bottom = @max(a.atlas_dirty_bottom, s.v + raster_h); + a.glyphs.put(key, s) catch return null; + a.pen_x += slot_w; + return s; +} + +// Run once when a grip glyph enters the atlas, after decorations. Copy only +// visible ink so bearings, empty bitmap margins and bold all share one center. +fn centerGlyphInk(out: [*]u8, width: usize, height: usize) void { + const b = inkBounds(out[0 .. (height - 1) * atlas_w + width], atlas_w, width, height) orelse return; + const w = b.max_x - b.min_x + 1; + const h = b.max_y - b.min_y + 1; + const left = (width - w) / 2; + const top = (height - h) / 2; + var scratch: [atlas_w]u8 = undefined; + for (0..h) |step| { + const row = if (top > b.min_y) h - 1 - step else step; + const source = (b.min_y + row) * atlas_w + b.min_x; + const target = (top + row) * atlas_w; + @memcpy(scratch[0..w], out[source..][0..w]); + @memset(out[target..][0..width], 0); + @memcpy(out[target + left ..][0..w], scratch[0..w]); + } + for (0..height) |row| { + if (row < top or row >= top + h) @memset(out[row * atlas_w ..][0..width], 0); + } +} + +// Underline and strikethrough stay inside the existing atlas slot, so text +// advance, caret and selection geometry are identical to the regular glyph. +// The cached mask keeps this work out of steady-state rendering and also +// decorates terminal spaces. Bold is not drawn here: the rasterizer emboldens +// the outline. +fn decorateLine(out: [*]u8, stride: usize, width: usize, height: usize, baseline: i32, decoration: Decoration, line_px: usize) void { + if (width == 0 or height == 0) return; + // A line is a logical pixel thick, its dots and waves as long: the same + // weight at any density (`line_px`, pardes's dp(1)). + const t: usize = line_px; + if (decoration.underline != .off) { + const base: usize = @intCast(@max(0, baseline)); + const row = @min(base + 1, height -| t); + for (0..width) |x| { + const top = switch (decoration.underline) { + .off => unreachable, + .single => row, + .double => { + const upper = @min(base + 1, height -| 3 * t); + for (0..t) |k| { + out[@min(upper + k, height - 1) * stride + x] = 255; + out[@min(upper + 2 * t + k, height - 1) * stride + x] = 255; + } + continue; + }, + .curly => row -| @as(usize, if (x % (4 * t) < 2 * t) t else 0), + .dotted => if (x % (3 * t) < t) row else continue, + .dashed => if (x % (6 * t) < 4 * t) row else continue, + }; + for (0..t) |k| out[@min(top + k, height - 1) * stride + x] = 255; + } + } + if (decoration.strikethrough) { + const row = @min(height -| t, @as(usize, @intCast(@max(0, baseline))) * 2 / 3); + for (0..t) |k| @memset(out[@min(row + k, height - 1) * stride ..][0..width], 255); + } +} + +/// ui_malloc and friends for this file's own test binary, which has no +/// embedder to export them: C's heap. A test that reaches FreeType or +/// HarfBuzz names it, so only that binary exports them. +const TestHeap = struct { + fn malloc(size: usize) callconv(.c) ?*anyopaque { + return std.c.malloc(size); + } + fn calloc(count: usize, size: usize) callconv(.c) ?*anyopaque { + return std.c.calloc(count, size); + } + fn realloc(block: ?*anyopaque, size: usize) callconv(.c) ?*anyopaque { + return std.c.realloc(block, size); + } + fn free(block: ?*anyopaque) callconv(.c) void { + std.c.free(block); + } + comptime { + @export(&malloc, .{ .name = "ui_malloc" }); + @export(&calloc, .{ .name = "ui_calloc" }); + @export(&realloc, .{ .name = "ui_realloc" }); + @export(&free, .{ .name = "ui_free" }); + } +}; + +test "FreeType atlas raster is grayscale, bounded, and clears blank cells" { + _ = TestHeap; + const font_ttf = @embedFile("AdwaitaMono-Regular.ttf"); + const font = c.ui_font_new(font_ttf.ptr, @intCast(font_ttf.len)).?; + defer c.ui_font_free(font); + const h = c.ui_font_glyph(font, 'H'); + try std.testing.expect(h != 0); + try std.testing.expectEqual(@as(u32, 0), c.ui_font_glyph(font, 0x10ffff)); + + const size: f32 = 13.0; + var cell_w: c_int = 0; + var cell_h: c_int = 0; + var ascent: c_int = 0; + c.ui_font_cell_metrics(font, size, &cell_w, &cell_h, &ascent); + try std.testing.expect(cell_w > 0 and cell_w <= 128); + try std.testing.expect(cell_h > 0 and cell_h <= 128); + + const stride: c_int = 128; + var bitmap: [128 * 128]u8 = @splat(0xaa); + try std.testing.expectEqual( + @as(c_int, 1), + c.ui_font_raster(font, size, h, 0, &bitmap, stride, cell_w, cell_h, 0, cell_w, ascent), + ); + + var ink: usize = 0; + var soft: usize = 0; + var regular_coverage: usize = 0; + for (0..@intCast(cell_h)) |y| { + for (0..@intCast(cell_w)) |x| { + const coverage = bitmap[y * @as(usize, @intCast(stride)) + x]; + if (coverage > 0) ink += 1; + if (coverage > 0 and coverage < 255) soft += 1; + regular_coverage += coverage; + } + } + try std.testing.expect(ink > 0); + try std.testing.expect(soft > 0); + // Synthetic bold thickens the outline inside the same cell. + try std.testing.expectEqual( + @as(c_int, 1), + c.ui_font_raster(font, size, h, 1, &bitmap, stride, cell_w, cell_h, 0, cell_w, ascent), + ); + var bold_coverage: usize = 0; + for (0..@intCast(cell_h)) |y| { + for (0..@intCast(cell_w)) |x| bold_coverage += bitmap[y * @as(usize, @intCast(stride)) + x]; + for (bitmap[y * @as(usize, @intCast(stride)) + @as(usize, @intCast(cell_w)) ..][0..@intCast(stride - cell_w)]) |guard| + try std.testing.expectEqual(@as(u8, 0xaa), guard); + } + try std.testing.expect(bold_coverage > regular_coverage); + + try std.testing.expectEqual( + @as(c_int, 0), + c.ui_font_raster(font, size, c.ui_font_glyph(font, ' '), 0, &bitmap, stride, cell_w, cell_h, 0, cell_w, ascent), + ); + for (0..@intCast(cell_h)) |y| + for (0..@intCast(cell_w)) |x| + try std.testing.expectEqual( + @as(u8, 0), + bitmap[y * @as(usize, @intCast(stride)) + x], + ); +} + +test "a box-drawing rule reaches its cell's edges, and only its arms do" { + const stride = 12; + const width = 9; + const height = 15; + var mask: [stride * height]u8 = @splat(0xa5); + drawRule(&mask, stride, width, height, ruleArms(0x253c).?, 1); + // ┼: ink on all four edges, none in the corners, nothing past the slot. + try std.testing.expectEqual(@as(u8, 255), mask[0 * stride + width / 2]); + try std.testing.expectEqual(@as(u8, 255), mask[(height - 1) * stride + width / 2]); + try std.testing.expectEqual(@as(u8, 255), mask[(height / 2) * stride]); + try std.testing.expectEqual(@as(u8, 255), mask[(height / 2) * stride + width - 1]); + try std.testing.expectEqual(@as(u8, 0), mask[0]); + for (0..height) |y| for (mask[y * stride + width ..][0 .. stride - width]) |guard| try std.testing.expectEqual(@as(u8, 0xa5), guard); + drawRule(&mask, stride, width, height, ruleArms(0x2502).?, 1); + try std.testing.expectEqual(@as(u8, 0), mask[(height / 2) * stride]); + try std.testing.expectEqual(@as(u8, 255), mask[0 * stride + width / 2]); + try std.testing.expect(ruleArms('|') == null); +} + +test "glyph decorations render spaces and stay inside their atlas slot" { + const stride = 9; + const width = 5; + const height = 7; + for ([_]Decoration{ + .{ .underline = .single }, + .{ .underline = .double }, + .{ .underline = .curly }, + .{ .underline = .dotted }, + .{ .underline = .dashed }, + .{ .strikethrough = true }, + }) |decoration| { + var mask: [stride * (height + 1)]u8 = @splat(0xa5); + for (0..height) |y| @memset(mask[y * stride ..][0..width], 0); + decorateLine(&mask, stride, width, height, 5, decoration, 1); + try std.testing.expect(inkBounds(&mask, stride, width, height) != null); + for (0..height) |y| for (mask[y * stride + width ..][0 .. stride - width]) |guard| + try std.testing.expectEqual(@as(u8, 0xa5), guard); + for (mask[stride * height ..]) |guard| try std.testing.expectEqual(@as(u8, 0xa5), guard); + } +} + +test "the atlas's dirty rows hold every row a new glyph draws into, and a reset dirties them all" { + _ = TestHeap; + var a = try Atlas.init(std.testing.allocator, @embedFile("AdwaitaMono-Regular.ttf")); + defer a.deinit(std.testing.allocator); + // The body at 18 px, the tagline at 14 px in the body's cell (pardes + // sizes it so, at its tagline percent). + var cell_w: c_int = 0; + var cell_h: c_int = 0; + var ascent: c_int = 0; + a.cellMetrics(18, &cell_w, &cell_h, &ascent); + const body: Size = .{ .px = 18, .cell_w = @intCast(cell_w), .height = @intCast(cell_h), .baseline = ascent }; + a.cellMetrics(14, &cell_w, &cell_h, &ascent); + const tagline: Size = .{ .px = 14, .cell_w = @intCast(@min(cell_w, body.cell_w)), .height = @intCast(@min(cell_h, body.height)), .baseline = @min(ascent, cell_h) }; + a.reset(body.cell_w); + // The texture as an upload of the dirty rows leaves it, which starts undefined. + const texture = try std.testing.allocator.alloc(u8, atlas_w * atlas_h); + defer std.testing.allocator.free(texture); + @memset(texture, 0xa5); + var glyph: u32 = 0; + for (0..40) |frame| { + if (frame == 30) a.reset(body.cell_w); // a font change + // Plain glyphs, strips, taglines, grip glyphs and decorations. + for (0..25) |_| { + glyph += 1; + const span: u4 = @intCast(1 + glyph % 3); + _ = a.cachedGlyph(.{ + .face = 0, + .glyph = glyph, + .role = if (glyph % 4 == 0) .tagline else .body, + .decoration = .{ .bold = glyph % 2 == 0, .underline = if (glyph % 5 == 0) .curly else .off, .strikethrough = glyph % 11 == 0 }, + .centered = glyph % 13 == 0, + .lead = @intCast(glyph % span), + .span = span, + }, body, tagline, 2, 1) orelse return error.AtlasFull; + } + for (0..atlas_h) |row| { + const stage = a.atlas_stage[row * atlas_w ..][0..atlas_w]; + const uploaded = texture[row * atlas_w ..][0..atlas_w]; + if (row >= a.atlas_dirty_top and row < a.atlas_dirty_bottom) + @memcpy(uploaded, stage) + else + try std.testing.expect(std.mem.eql(u8, stage, uploaded)); + } + a.atlas_dirty_top = atlas_h; + a.atlas_dirty_bottom = 0; + } + try std.testing.expect(a.pen_y >= 2 * body.height); +} diff --git a/vendor/README.md b/vendor/README.md index c23a785..1d3e42b 100644 --- a/vendor/README.md +++ b/vendor/README.md @@ -9,6 +9,10 @@ Single-file codecs, vendored unchanged; `codecs.c` compiles them for the host. `cgltf.c` compiles the unchanged cgltf header for the optional `gltf` module. +`font.c` and `font.h` are pardes's FreeType and HarfBuzz shim, moved from its +`src/gui/` unchanged, under `src/font/Atlas.zig`. The embedder compiles them +against its own FreeType and HarfBuzz and exports `ui_malloc` and friends. + `presentation-time/presentation-time.xml` is the Wayland presentation-time v3 protocol description (the client binds v1; its license is included in the XML). On Linux, `build.zig` runs `wayland-scanner` to generate a client header and C diff --git a/vendor/font.c b/vendor/font.c new file mode 100644 index 0000000..aebe26e --- /dev/null +++ b/vendor/font.c @@ -0,0 +1,471 @@ +// FreeType and HarfBuzz wrapper for gui.zig. The policy intentionally follows +// Ghostty's FreeType backend: native hinting enabled, the auto-hinter available +// as a fallback, and the light target for shape-preserving grayscale text. +// HarfBuzz only picks glyphs (liga, calt); the grid, not the font's advances, +// places them. +#include "font.h" +#include +#include +#include +#include +#include +#include + +#include + +struct UIFont { + // FreeType allocates through ui_malloc and friends: the library holds a + // pointer to this for its lifetime, which the UIFont outlives. + struct FT_MemoryRec_ memory; + FT_Library library; + FT_Face face; + FT_F26Dot6 size; + // The charmap's answer for ASCII, which is most of every screen: a word the + // renderer has not seen before looks up each of its cells. + uint32_t ascii[128]; + // HarfBuzz state, made by the first ui_font_substitutes question (most + // fallback faces are never asked). + hb_font_t *hb; + hb_buffer_t *buffer; + FT_F26Dot6 hb_size; + // Every glyph a lookup of a ligature feature could replace. Nothing else + // can change a glyph, so a cell outside it is its nominal glyph without + // shaping: every cell, in a font without ligatures. + hb_set_t *substitutes; + // ui_font_shape's per-cell scratch, grown to the longest run seen + uint32_t *own; + uint8_t *state; + int32_t scratch; +}; + +static FT_F26Dot6 size_26_6(float px) { + if (px < 1.0f) + px = 1.0f; + return (FT_F26Dot6)(px * 64.0f + 0.5f); +} + +static int set_size(UIFont *f, float px) { + const FT_F26Dot6 size = size_26_6(px); + if (f->size == size) + return 1; + if (FT_Set_Char_Size(f->face, 0, size, 72, 72) != 0) + return 0; + f->size = size; + return 1; +} + +static int ceil_26_6(FT_Pos value) { return (int)((value + 63) >> 6); } + +static FT_Int32 load_flags(void) { + // Hinting is on because FT_LOAD_NO_HINTING is absent. Likewise, leaving + // FT_LOAD_NO_AUTOHINT absent lets FreeType fall back to its auto-hinter + // when the face has no native instructions. This is Ghostty's default. + return FT_LOAD_DEFAULT | FT_LOAD_TARGET_LIGHT; +} + +static void *ft_alloc(FT_Memory memory, long size) { + (void)memory; + return ui_malloc((size_t)size); +} + +static void ft_free(FT_Memory memory, void *block) { + (void)memory; + ui_free(block); +} + +static void *ft_realloc(FT_Memory memory, long cur_size, long new_size, + void *block) { + (void)memory; + (void)cur_size; + return ui_realloc(block, (size_t)new_size); +} + +UIFont *ui_font_new(const uint8_t *data, int32_t len) { + if (!data || len <= 0) + return NULL; + + UIFont *f = (UIFont *)ui_calloc(1, sizeof(UIFont)); + if (!f) + return NULL; + // FT_Init_FreeType is exactly FT_New_Library over FT_New_Memory's malloc + // manager, then the default modules and properties: the same, over ours. + f->memory = (struct FT_MemoryRec_){NULL, ft_alloc, ft_free, ft_realloc}; + if (FT_New_Library(&f->memory, &f->library) != 0) { + ui_free(f); + return NULL; + } + FT_Add_Default_Modules(f->library); + FT_Set_Default_Properties(f->library); + if (FT_New_Memory_Face(f->library, data, (FT_Long)len, 0, &f->face) != 0) { + FT_Done_Library(f->library); + ui_free(f); + return NULL; + } + // Some symbol fonts do not expose a Unicode charmap. FreeType already + // selects a usable default for those, so failure here is non-fatal. + (void)FT_Select_Charmap(f->face, FT_ENCODING_UNICODE); + for (uint32_t cp = 0; cp < 128; cp++) + f->ascii[cp] = FT_Get_Char_Index(f->face, cp); + return f; +} + +// HarfBuzz reads this same face (and its charmap) through FreeType, so shaping +// and rasterizing agree on glyph ids. None of these calls returns NULL: a +// failure is an inert empty object, and shaping then yields nominal glyphs. +static void start_harfbuzz(UIFont *f) { + f->hb = hb_ft_font_create_referenced(f->face); + f->buffer = hb_buffer_create(); + f->substitutes = hb_set_create(); + static const hb_tag_t features[] = { + HB_TAG('l', 'i', 'g', 'a'), HB_TAG('c', 'a', 'l', 't'), + HB_TAG('c', 'l', 'i', 'g'), HB_TAG('r', 'l', 'i', 'g'), + HB_TAG('r', 'c', 'l', 't'), HB_TAG_NONE}; + hb_face_t *face = hb_font_get_face(f->hb); + hb_set_t *lookups = hb_set_create(); + hb_ot_layout_collect_lookups(face, HB_OT_TAG_GSUB, NULL, NULL, features, + lookups); + hb_codepoint_t lookup = HB_SET_VALUE_INVALID; + while (hb_set_next(lookups, &lookup)) + hb_ot_layout_lookup_collect_glyphs(face, HB_OT_TAG_GSUB, lookup, NULL, + f->substitutes, NULL, NULL); + hb_set_destroy(lookups); +} + +const char *ui_font_name(UIFont *f) { + if (!f || !f->face) + return NULL; + const char *postscript = FT_Get_Postscript_Name(f->face); + if (postscript && postscript[0]) + return postscript; + if (f->face->family_name && f->face->family_name[0]) + return f->face->family_name; + return NULL; +} + +uint32_t ui_font_glyph(UIFont *f, int32_t cp) { + if (!f || cp < 0) + return 0; + if (cp < 128) + return f->ascii[cp]; + return FT_Get_Char_Index(f->face, (FT_ULong)(uint32_t)cp); +} + +void ui_font_free(UIFont *f) { + if (!f) + return; + // The HarfBuzz font holds a reference on the face: release it first. (All + // three accept NULL, a face that never shaped.) + hb_set_destroy(f->substitutes); + hb_buffer_destroy(f->buffer); + hb_font_destroy(f->hb); + if (f->face) + FT_Done_Face(f->face); + if (f->library) + FT_Done_Library(f->library); + ui_free(f->own); + ui_free(f->state); + ui_free(f); +} + +void ui_font_prime(UIFont *f) { + if (!f) + return; + hb_font_destroy(hb_ft_font_create_referenced(f->face)); + hb_buffer_t *buffer = hb_buffer_create(); + hb_buffer_add_utf8(buffer, "a", 1, 0, 1); + hb_buffer_guess_segment_properties(buffer); + hb_buffer_destroy(buffer); +} + +void ui_font_cell_metrics(UIFont *f, float px, int32_t *cell_w, int32_t *cell_h, + int32_t *ascent) { + if (!f || !cell_w || !cell_h || !ascent || !set_size(f, px)) { + if (cell_w) + *cell_w = 1; + if (cell_h) + *cell_h = 1; + if (ascent) + *ascent = 1; + return; + } + + const FT_Size_Metrics metrics = f->face->size->metrics; + const int asc = ceil_26_6(metrics.ascender); + const int desc = ceil_26_6(-metrics.descender); + int height = ceil_26_6(metrics.height); + if (height < asc + desc) + height = asc + desc; + + int width = ceil_26_6(metrics.max_advance); + const FT_UInt m = FT_Get_Char_Index(f->face, 'M'); + if (FT_Load_Glyph(f->face, m, load_flags()) == 0) { + const int advance = ceil_26_6(f->face->glyph->advance.x); + if (advance > 0) + width = advance; + } + + *cell_w = width > 0 ? width : 1; + *cell_h = height > 0 ? height : 1; + *ascent = asc > 0 ? asc : 1; +} + +static int raster(UIFont *f, float px, uint32_t glyph_index, int bold, + uint8_t *out, int32_t stride, int32_t width, int32_t height, + int32_t cell_x, int32_t cell_w, int32_t ascent, + int centered) { + if (!f || !out || stride < width || width <= 0 || height <= 0) + return 0; + for (int y = 0; y < height; y++) + memset(out + (size_t)y * (size_t)stride, 0, (size_t)width); + if (!set_size(f, px)) + return 0; + + if (FT_Load_Glyph(f->face, glyph_index, load_flags()) != 0) + return 0; + if (bold) { + // Synthetic bold thickens the hinted outline before it is rendered, so + // the wider stems are rasterized as one shape and keep hinted edges; the + // advance is untouched, as the cell grid requires. Strength is Ghostty's + // heuristic: 1/32 of the line height in 26.6, rounded up (one pixel at a + // 32 px line). A bitmap strike has no outline: widen it by one whole pixel, + // the classic overstrike, which keeps its pixels sharp. + FT_GlyphSlot slot = f->face->glyph; + if (slot->format == FT_GLYPH_FORMAT_OUTLINE) { + const FT_Pos height = f->face->size->metrics.height; + FT_Outline_Embolden(&slot->outline, (height + 31) / 32); + } else if (slot->format == FT_GLYPH_FORMAT_BITMAP && + FT_GlyphSlot_Own_Bitmap(slot) == 0) { + FT_Bitmap_Embolden(f->library, &slot->bitmap, 64, 0); + } + } + if (FT_Render_Glyph(f->face->glyph, FT_RENDER_MODE_NORMAL) != 0) + return 0; + + const FT_GlyphSlot glyph = f->face->glyph; + const FT_Bitmap *bitmap = &glyph->bitmap; + if (!bitmap->buffer || bitmap->width == 0 || bitmap->rows == 0) + return 0; + + const int advance = ceil_26_6(glyph->advance.x); + // Fallbacks may be proportional. Center their advance in the primary face's + // fixed cell, exactly as Ghostty centers a narrower fallback face. + const int gx = centered + ? (width - (int)bitmap->width) / 2 + : cell_x + glyph->bitmap_left + (cell_w - advance) / 2; + const int gy = + centered ? (height - (int)bitmap->rows) / 2 : ascent - glyph->bitmap_top; + const int pitch = bitmap->pitch; + const int row_bytes = pitch < 0 ? -pitch : pitch; + + for (unsigned int y = 0; y < bitmap->rows; y++) { + const int dy = gy + (int)y; + if (dy < 0 || dy >= height) + continue; + const unsigned int source_y = pitch < 0 ? bitmap->rows - 1 - y : y; + const uint8_t *src = bitmap->buffer + (size_t)source_y * (size_t)row_bytes; + + for (unsigned int x = 0; x < bitmap->width; x++) { + const int dx = gx + (int)x; + if (dx < 0 || dx >= width) + continue; + + uint8_t coverage; + if (bitmap->pixel_mode == FT_PIXEL_MODE_MONO) { + coverage = (src[x >> 3] & (0x80u >> (x & 7))) ? 255 : 0; + } else if (bitmap->pixel_mode == FT_PIXEL_MODE_GRAY) { + coverage = src[x]; + if (bitmap->num_grays > 1 && bitmap->num_grays != 256) + coverage = (uint8_t)((unsigned int)coverage * 255u / + (bitmap->num_grays - 1u)); + } else { + continue; + } + out[(size_t)dy * (size_t)stride + (size_t)dx] = coverage; + } + } + return 1; +} + +int ui_font_raster(UIFont *f, float px, uint32_t glyph, int bold, uint8_t *out, + int32_t stride, int32_t width, int32_t height, + int32_t cell_x, int32_t cell_w, int32_t ascent) { + return raster(f, px, glyph, bold, out, stride, width, height, cell_x, cell_w, + ascent, 0); +} + +int ui_font_raster_centered(UIFont *f, float px, uint32_t glyph, int bold, + uint8_t *out, int32_t stride, int32_t width, + int32_t height) { + return raster(f, px, glyph, bold, out, stride, width, height, 0, width, 0, 1); +} + +// The horizontal ink of `glyph` placed as ui_font_raster places it in a cell +// `cell` wide (26.6), relative to the cell's left edge. 0 when it has no ink. +static int ink(UIFont *f, uint32_t glyph, FT_Pos cell, FT_Pos *left, + FT_Pos *right) { + if (FT_Load_Glyph(f->face, glyph, load_flags()) != 0) + return 0; + const FT_GlyphSlot slot = f->face->glyph; + if (slot->metrics.width <= 0 || slot->metrics.height <= 0) + return 0; + const FT_Pos origin = + (FT_Pos)(((int)(cell >> 6) - ceil_26_6(slot->advance.x)) / 2) * 64; + *left = origin + slot->metrics.horiBearingX; + *right = *left + slot->metrics.width; + return 1; +} + +// ui_font_shape's per-cell marks: no glyph of its own, keep the nominal glyph, +// drawn as a slice of another cell's glyph. +#define NONE UINT32_MAX +#define PLAIN 1 +#define CLAIMED 2 + +int ui_font_substitutes(UIFont *f, uint32_t glyph) { + if (!f) + return 0; + if (!f->hb) + start_harfbuzz(f); + return hb_set_has(f->substitutes, glyph); +} + +// The GSUB features shaping leaves on are the ligature ones; the others +// HarfBuzz would apply (glyph composition, local forms, fractions around +// U+2044, ...) are off, so a cell is either its nominal glyph, as the renderer +// always drew it, or part of a ligature. Positioning is untouched: the grid +// ignores advances and keeps nominal glyphs where marks would move. +static const hb_feature_t shaping_features[] = { + {HB_TAG('c', 'c', 'm', 'p'), 0, 0, (unsigned int)-1}, + {HB_TAG('l', 'o', 'c', 'l'), 0, 0, (unsigned int)-1}, + {HB_TAG('r', 'v', 'r', 'n'), 0, 0, (unsigned int)-1}, + {HB_TAG('l', 't', 'r', 'a'), 0, 0, (unsigned int)-1}, + {HB_TAG('l', 't', 'r', 'm'), 0, 0, (unsigned int)-1}, + {HB_TAG('r', 'a', 'n', 'd'), 0, 0, (unsigned int)-1}, + {HB_TAG('f', 'r', 'a', 'c'), 0, 0, (unsigned int)-1}, + {HB_TAG('n', 'u', 'm', 'r'), 0, 0, (unsigned int)-1}, + {HB_TAG('d', 'n', 'o', 'm'), 0, 0, (unsigned int)-1}, +}; + +void ui_font_shape(UIFont *f, float px, int32_t cell_w, const uint32_t *cps, + int32_t n, UIShapedCell *out) { + if (!f || !cps || !out || n <= 0) + return; + for (int32_t i = 0; i < n; i++) + out[i] = (UIShapedCell){ui_font_glyph(f, (int32_t)cps[i]), 0, 1, 0}; + if (!f->hb) + start_harfbuzz(f); + int substitutable = 0; + for (int32_t i = 0; i < n && !substitutable; i++) + substitutable = hb_set_has(f->substitutes, out[i].glyph); + if (!substitutable || cell_w <= 0 || !set_size(f, px)) + return; + if (n > f->scratch) { + uint32_t *own = (uint32_t *)ui_realloc(f->own, (size_t)n * sizeof *own); + if (!own) + return; + f->own = own; + uint8_t *state = (uint8_t *)ui_realloc(f->state, (size_t)n); + if (!state) + return; + f->state = state; + f->scratch = n; + } + // hb-ft reads the FreeType size when told; positions are only consulted + // for being nonzero, but a zero scale would hide exactly that. + if (f->hb_size != f->size) { + hb_ft_font_changed(f->hb); + f->hb_size = f->size; + } + hb_buffer_clear_contents(f->buffer); + // One codepoint per cell, so a cluster value IS a cell index. + hb_buffer_add_codepoints(f->buffer, cps, n, 0, n); + hb_buffer_set_direction(f->buffer, HB_DIRECTION_LTR); + hb_buffer_guess_segment_properties(f->buffer); + hb_shape(f->hb, f->buffer, shaping_features, + sizeof shaping_features / sizeof shaping_features[0]); + unsigned int count = 0; + const hb_glyph_info_t *info = hb_buffer_get_glyph_infos(f->buffer, &count); + const hb_glyph_position_t *pos = + hb_buffer_get_glyph_positions(f->buffer, &count); + + // Each cell's own glyph is the one HarfBuzz left in its cluster. A cell a + // ligature merged into an earlier cluster has NONE. A cluster the grid + // cannot place (several glyphs, a positioned mark) is PLAIN, and so are the + // cells merged into it: they keep their nominal glyphs. + uint32_t *own = f->own; + uint8_t *state = f->state; + for (int32_t i = 0; i < n; i++) { + own[i] = NONE; + state[i] = 0; + } + for (unsigned int k = 0; k < count; k++) { + const uint32_t cluster = info[k].cluster; + if (cluster >= (uint32_t)n) + continue; + if (own[cluster] != NONE || pos[k].x_offset != 0 || pos[k].y_offset != 0) + state[cluster] = PLAIN; + else + own[cluster] = info[k].codepoint; + } + for (int32_t i = 1; i < n; i++) + if (own[i] == NONE && (state[i - 1] & PLAIN)) + state[i] = PLAIN; + + // A substituted glyph (or one whose cluster swallowed cells) may reach over + // its neighbours: it claims those that draw nothing of their own, nearest + // first, and each draws its slice of the one strip. Ink past a cell edge by + // half a pixel or less is noise. + const FT_Pos cell = (FT_Pos)cell_w * 64; + for (int32_t i = 0; i < n; i++) { + if ((state[i] & (PLAIN | CLAIMED)) || own[i] == NONE) + continue; + int32_t merged = 0; + while (i + 1 + merged < n && own[i + 1 + merged] == NONE && + !(state[i + 1 + merged] & PLAIN)) + merged++; + if (own[i] == out[i].glyph && merged == 0) + continue; + FT_Pos left = 0, right = 0; + if (!ink(f, own[i], cell, &left, &right)) + continue; // a spacer: claimed, never claiming + int32_t want_left = + left < -32 ? (int32_t)((-left - 32 + cell - 1) / cell) : 0; + int32_t want_right = right > cell + 32 + ? (int32_t)((right - cell - 32 + cell - 1) / cell) + : 0; + if (want_right < merged) + want_right = merged; + int32_t lead = 0, trail = 0; + while (lead < want_left && 1 + lead + trail < UI_MAX_SPAN) { + const int32_t j = i - lead - 1; + FT_Pos l, r; + if (j < 0 || (state[j] & (PLAIN | CLAIMED)) || + (own[j] != NONE && + (own[j] == out[j].glyph || ink(f, own[j], cell, &l, &r)))) + break; + lead++; + } + while (trail < want_right && 1 + lead + trail < UI_MAX_SPAN) { + const int32_t j = i + trail + 1; + FT_Pos l, r; + if (j >= n || (state[j] & (PLAIN | CLAIMED)) || + (own[j] != NONE && + (own[j] == out[j].glyph || ink(f, own[j], cell, &l, &r)))) + break; + trail++; + } + for (int32_t j = i - lead; j <= i + trail; j++) { + out[j] = + (UIShapedCell){own[i], (uint8_t)lead, (uint8_t)(1 + lead + trail), + (uint8_t)(j - (i - lead))}; + state[j] |= CLAIMED; + } + } + // The rest draw their own glyph; a merged cell nothing claimed draws blank. + const uint32_t space = f->ascii[' ']; + for (int32_t i = 0; i < n; i++) { + if (state[i] & (PLAIN | CLAIMED)) + continue; + out[i].glyph = own[i] == NONE ? space : own[i]; + } +} diff --git a/vendor/font.h b/vendor/font.h new file mode 100644 index 0000000..db964fb --- /dev/null +++ b/vendor/font.h @@ -0,0 +1,98 @@ +// Tiny C shim over FreeType and HarfBuzz, so gui.zig only imports the stable +// renderer API. The implementation owns FreeType's library and face objects +// and HarfBuzz's font and buffer, and keeps the caller's font bytes borrowed +// for the face lifetime. +#ifndef UI_FONT_H +#define UI_FONT_H +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct UIFont UIFont; + +// Every allocation FreeType, HarfBuzz and this shim make: C's malloc, calloc, +// realloc and free, implemented by gui.zig over a Zig allocator. HarfBuzz is +// compiled to call them (hb_malloc_impl and friends); FreeType gets them as +// each library's memory manager. +void *ui_malloc(size_t size); +void *ui_calloc(size_t count, size_t size); +void *ui_realloc(void *block, size_t size); +void ui_free(void *block); + +// Parse the first face in an in-memory font. `data` must stay alive for the +// lifetime of the font. Returns NULL on failure. +UIFont *ui_font_new(const uint8_t *data, int32_t len); + +// The face FreeType actually accepted. Prefer its PostScript name (the same +// identity the macOS shell reports); fall back to the family name when the +// font has no PostScript table. Borrowed for the UIFont lifetime. +const char *ui_font_name(UIFont *f); + +// The glyph the selected Unicode charmap maps `cp` to. Glyph zero is the +// face's .notdef box: the codepoint is missing, which is what fallback choice +// asks. +uint32_t ui_font_glyph(UIFont *f, int32_t cp); + +// `px` is the pixel height. Metrics and rasterization both configure FreeType +// at that size, so hinted advances, baseline and bitmaps stay in step. +void ui_font_cell_metrics(UIFont *f, float px, int32_t *cell_w, int32_t *cell_h, + int32_t *ascent); + +// What one grid cell draws: `slice` of the glyph `glyph` rasterized across +// `span` cells with its own cell `lead` cells from the left. A plain cell is +// its own glyph, lead 0, span 1, slice 0. +typedef struct { + uint32_t glyph; + uint8_t lead; + uint8_t span; + uint8_t slice; +} UIShapedCell; + +// The longest glyph strip a ligature may claim, in cells. +#define UI_MAX_SPAN 8 + +// Whether a lookup of the font's ligature features (liga, calt, clig, rlig, +// rclt) could replace `glyph`. When it cannot, shaping leaves the glyph alone +// and its cell needs no shaping at all. +int ui_font_substitutes(UIFont *f, uint32_t glyph); + +// One cell per codepoint of `cps`, all in this face, shaped by HarfBuzz with +// the font's ligature features (a run with no glyph ui_font_substitutes +// reports comes back nominal without it). A substituted glyph whose ink +// reaches over neighbouring cells that draw nothing of their own (a +// ligature's spacers, or the cells a merged cluster swallowed) claims them as +// a strip. Otherwise, and for anything the grid cannot place (several glyphs +// in one cell, positioned marks), each cell is its nominal glyph. +void ui_font_shape(UIFont *f, float px, int32_t cell_w, const uint32_t *cps, + int32_t n, UIShapedCell *out); + +// Rasterize `glyph` into `out` as a hinted grayscale mask of `width` x +// `height` (`stride` bytes per row). The glyph's advance is centered in the +// `cell_w` pixels that start at `cell_x`, and its baseline is `ascent` pixels +// from the top; ink outside the mask is clipped. `bold` emboldens the outline +// before rendering (synthetic bold, same advance). Returns 1 when the glyph +// produced coverage, 0 for blank/error. +int ui_font_raster(UIFont *f, float px, uint32_t glyph, int bold, uint8_t *out, + int32_t stride, int32_t width, int32_t height, + int32_t cell_x, int32_t cell_w, int32_t ascent); + +// Center bitmap ink bounds, independent of advance and baseline bearings. +int ui_font_raster_centered(UIFont *f, float px, uint32_t glyph, int bold, + uint8_t *out, int32_t stride, int32_t width, + int32_t height); + +void ui_font_free(UIFont *f); + +// HarfBuzz makes a few process-wide objects on first use and keeps them for +// the life of the process (the default Unicode functions, the locale's +// language, hb-ft's font functions). Making them here, with `f`'s face, lets +// the caller hand them an allocator that does not count them as leaks. +void ui_font_prime(UIFont *f); + +#ifdef __cplusplus +} +#endif +#endif -- cgit v1.3