1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
|
//! The host's text. A `Command.text` is shaped by vendor/text.c at its
//! canvas size (what `textRun` measured), and each glyph is rasterized by
//! pardes's font.c at the size it lands on the device, kept in one
//! 2048x2048 coverage atlas: shelves of trimmed ink boxes, cleared and
//! refilled when full (pardes's policy: no eviction). The texture holds
//! white premultiplied by coverage, so a vertex colour is the ink and the
//! coverage is mixed once, with no gamma. The glyphs of consecutive text
//! commands are one geometry call (`flush`, which the Painter calls before
//! anything else it draws). Upright text lands on whole device pixels and
//! samples NEAREST; `textScaled` (and a glyph past 512 device pixels,
//! rastered at 512) is placed unsnapped and samples LINEAR.
const Glyphs = @This();
const std = @import("std");
const abi = @import("abi");
const c = @import("c");
const Atlas = @import("font_atlas");
const side = Atlas.atlas_w;
/// The largest raster, in device pixels: a bigger glyph is this one, stretched.
const max_px = 512;
/// A glyph of a face at a device size, in 64ths of a pixel.
const Key = packed struct(u64) { face: u8, glyph: u32, px: u24 };
/// Its ink box in the atlas, and where that box sits from the pen's origin
/// on the baseline (device pixels, y down). Empty: nothing to draw.
const Slot = struct { u: u16 = 0, v: u16 = 0, w: u16 = 0, h: u16 = 0, dx: i16 = 0, dy: i16 = 0 };
gpa: std.mem.Allocator,
/// Coverage, a byte a texel: `texture`'s contents to come.
stage: []u8 = &.{},
texture: ?*c.SDL_Texture = null,
slots: std.AutoHashMapUnmanaged(Key, Slot) = .empty,
/// The shelf being filled: its top, its height so far, and the pen in it.
shelf: struct { x: u32 = 0, y: u32 = 0, h: u32 = 0 } = .{},
/// What the stage changed since the last upload: x0, y0, x1, y1.
dirty: [4]u32 = .{ 0, 0, side, side },
/// A glyph's raster before it is trimmed, and the shaped glyphs of a run.
raster: std.ArrayList(u8) = .empty,
shaped: std.ArrayList(c.SkGlyph) = .empty,
/// The pending geometry: six vertices a glyph, in logical units.
batch: std.ArrayList(c.SDL_Vertex) = .empty,
linear: bool = false,
pub fn deinit(g: *Glyphs) void {
if (g.texture) |t| c.SDL_DestroyTexture(t);
g.gpa.free(g.stage);
g.slots.deinit(g.gpa);
g.raster.deinit(g.gpa);
g.shaped.deinit(g.gpa);
g.batch.deinit(g.gpa);
g.* = .{ .gpa = g.gpa };
}
/// The canvas size `scale` is, in pixels: scale 1 is 13.
pub fn pixels(scale: f32) f32 {
return 13 * scale;
}
/// One `Command.text` into the batch.
pub fn draw(g: *Glyphs, renderer: *c.SDL_Renderer, t: @FieldType(abi.Command, "text")) void {
const raster = if (t.raster > 0) t.raster else t.scale;
if (t.bytes.len == 0 or t.color.a == 0 or !(t.scale > 0) or !std.math.isFinite(t.scale) or !std.math.isFinite(raster)) return;
if (g.texture == null and !g.start(renderer)) return;
// Shaped at the size it was measured at; `k` stretches that layout to
// the size drawn (textScaled), `dpi` to the device.
var advance: i32 = 0;
var ascent: i32 = 0;
var height: i32 = 0;
const face: c_int = @backingInt(t.face);
var n: usize = 0;
while (true) {
n = @intCast(c.sk_text_shape(face, pixels(raster), t.bytes.ptr, t.bytes.len, g.shaped.items.ptr, @intCast(g.shaped.items.len), &advance, &ascent, &height));
if (n <= g.shaped.items.len) break;
g.shaped.resize(g.gpa, n) catch return;
}
const k = t.scale / raster;
const dpi = density(renderer);
const wanted = pixels(t.scale) * dpi;
const px = @min(wanted, max_px);
const stretch = wanted / px;
const snapped = k == 1 and stretch == 1;
if (g.linear != !snapped) {
g.flush(renderer);
g.linear = !snapped;
}
const ink: c.SDL_FColor = .{
.r = @as(f32, @floatFromInt(t.color.r)) * @as(f32, @floatFromInt(t.color.a)) / (255 * 255),
.g = @as(f32, @floatFromInt(t.color.g)) * @as(f32, @floatFromInt(t.color.a)) / (255 * 255),
.b = @as(f32, @floatFromInt(t.color.b)) * @as(f32, @floatFromInt(t.color.a)) / (255 * 255),
.a = @as(f32, @floatFromInt(t.color.a)) / 255,
};
const unit = k * dpi; // device pixels a layout pixel
const origin: [2]f32 = .{ t.x * dpi, (t.y + @as(f32, @floatFromInt(ascent)) * k) * dpi };
for (g.shaped.items[0..n]) |glyph| {
const key: Key = .{ .face = glyph.face, .glyph = glyph.glyph, .px = @intFromFloat(@round(px * 64)) };
const slot = g.slotFor(renderer, key) orelse continue;
if (slot.w == 0) continue;
var at: [2]f32 = .{ origin[0] + @as(f32, @floatFromInt(glyph.x)) * unit, origin[1] + @as(f32, @floatFromInt(glyph.y)) * unit };
if (snapped) at = .{ @round(origin[0]) + @round(@as(f32, @floatFromInt(glyph.x)) * unit), @round(origin[1]) + @round(@as(f32, @floatFromInt(glyph.y)) * unit) };
const x0 = (at[0] + @as(f32, @floatFromInt(slot.dx)) * stretch) / dpi;
const y0 = (at[1] + @as(f32, @floatFromInt(slot.dy)) * stretch) / dpi;
const x1 = x0 + @as(f32, @floatFromInt(slot.w)) * stretch / dpi;
const y1 = y0 + @as(f32, @floatFromInt(slot.h)) * stretch / dpi;
const s: f32 = 1.0 / @as(f32, side);
const s0 = @as(f32, @floatFromInt(slot.u)) * s;
const t0 = @as(f32, @floatFromInt(slot.v)) * s;
const s1 = @as(f32, @floatFromInt(slot.u + slot.w)) * s;
const t1 = @as(f32, @floatFromInt(slot.v + slot.h)) * s;
const quad = g.batch.addManyAsArray(g.gpa, 6) catch return;
const tl: c.SDL_Vertex = .{ .position = .{ .x = x0, .y = y0 }, .color = ink, .tex_coord = .{ .x = s0, .y = t0 } };
const tr: c.SDL_Vertex = .{ .position = .{ .x = x1, .y = y0 }, .color = ink, .tex_coord = .{ .x = s1, .y = t0 } };
const bl: c.SDL_Vertex = .{ .position = .{ .x = x0, .y = y1 }, .color = ink, .tex_coord = .{ .x = s0, .y = t1 } };
const br: c.SDL_Vertex = .{ .position = .{ .x = x1, .y = y1 }, .color = ink, .tex_coord = .{ .x = s1, .y = t1 } };
quad.* = .{ tl, tr, bl, tr, br, bl };
}
}
/// Draws the batch: the stage's new rows uploaded, then one geometry call.
pub fn flush(g: *Glyphs, renderer: *c.SDL_Renderer) void {
if (g.batch.items.len == 0) return;
defer g.batch.clearRetainingCapacity();
const texture = g.texture orelse return;
g.upload();
_ = c.SDL_SetTextureScaleMode(texture, if (g.linear) c.SDL_SCALEMODE_LINEAR else c.SDL_SCALEMODE_NEAREST);
_ = c.SDL_RenderGeometry(renderer, texture, g.batch.items.ptr, @intCast(g.batch.items.len), null, 0);
}
fn start(g: *Glyphs, renderer: *c.SDL_Renderer) bool {
g.stage = g.gpa.alloc(u8, side * side) catch return false;
@memset(g.stage, 0);
const texture = c.SDL_CreateTexture(renderer, c.SDL_PIXELFORMAT_RGBA32, c.SDL_TEXTUREACCESS_STATIC, side, side) orelse {
g.gpa.free(g.stage);
g.stage = &.{};
return false;
};
_ = c.SDL_SetTextureBlendMode(texture, c.SDL_BLENDMODE_BLEND_PREMULTIPLIED);
g.texture = texture;
g.dirty = .{ 0, 0, side, side };
return true;
}
/// The stage's changed rectangle into the texture, coverage as white
/// premultiplied (r = g = b = a), 64 rows at a time.
fn upload(g: *Glyphs) void {
const d = g.dirty;
if (d[2] <= d[0] or d[3] <= d[1]) return;
const w = d[2] - d[0];
const band = 64;
g.raster.resize(g.gpa, w * band * 4) catch return;
var top = d[1];
while (top < d[3]) : (top += band) {
const h = @min(band, d[3] - top);
for (0..h) |y| for (0..w) |x| @memset(g.raster.items[(y * w + x) * 4 ..][0..4], g.stage[(top + y) * side + d[0] + x]);
const rect: c.SDL_Rect = .{ .x = @intCast(d[0]), .y = @intCast(top), .w = @intCast(w), .h = @intCast(h) };
_ = c.SDL_UpdateTexture(g.texture, &rect, g.raster.items.ptr, @intCast(w * 4));
}
g.dirty = .{ side, side, 0, 0 };
}
/// `key`'s slot, rasterized on first use; when the atlas is full, what is
/// pending is drawn and the atlas starts over. Null if it cannot hold it.
fn slotFor(g: *Glyphs, renderer: *c.SDL_Renderer, key: Key) ?Slot {
if (g.slots.get(key)) |s| return s;
return g.rasterize(key) orelse {
g.flush(renderer);
g.slots.clearRetainingCapacity();
@memset(g.stage, 0);
g.shelf = .{};
g.dirty = .{ 0, 0, side, side };
return g.rasterize(key);
};
}
/// font.c's raster of `key`, its advance centred on the pen as pardes
/// centres a cell's, a margin of half its size around it; then trimmed to
/// its ink and shelved. Null when the atlas has no room.
fn rasterize(g: *Glyphs, key: Key) ?Slot {
const px = @as(f32, @floatFromInt(key.px)) / 64;
const font = c.sk_text_ui(key.face) orelse return null;
var cell_w: c_int = 0;
var height: c_int = 0;
var ascent: c_int = 0;
c.ui_font_cell_metrics(font, px, &cell_w, &height, &ascent);
const advance = @max(0, c.sk_text_advance(key.face, px, key.glyph));
const pad: c_int = @intFromFloat(@ceil(px / 2) + 2);
const w: usize = @intCast(advance + 2 * pad);
const h: usize = @intCast(height + 2 * pad);
g.raster.resize(g.gpa, w * h) catch return null;
const blank = c.ui_font_raster(font, px, key.glyph, 0, g.raster.items.ptr, @intCast(w), @intCast(w), @intCast(h), pad, advance, ascent + pad) == 0;
const box = if (blank) null else Atlas.inkBounds(g.raster.items, w, w, h);
const b = box orelse {
g.slots.put(g.gpa, key, .{}) catch {};
return .{};
};
const bw: u32 = @intCast(b.max_x - b.min_x + 1);
const bh: u32 = @intCast(b.max_y - b.min_y + 1);
// A new shelf when this one is full; a gap of a texel around each box,
// so LINEAR sampling at its edge reads nothing of a neighbour.
if (g.shelf.x + bw + 1 > side) g.shelf = .{ .y = g.shelf.y + g.shelf.h };
if (g.shelf.y + bh + 1 > side or bw + 1 > side) return null;
const slot: Slot = .{ .u = @intCast(g.shelf.x), .v = @intCast(g.shelf.y), .w = @intCast(bw), .h = @intCast(bh), .dx = @intCast(@as(i64, @intCast(b.min_x)) - pad), .dy = @intCast(@as(i64, @intCast(b.min_y)) - pad - ascent) };
g.slots.put(g.gpa, key, slot) catch return null;
for (0..bh) |y| @memcpy(g.stage[(slot.v + y) * side + slot.u ..][0..bw], g.raster.items[(b.min_y + y) * w + b.min_x ..][0..bw]);
g.dirty = .{ @min(g.dirty[0], slot.u), @min(g.dirty[1], slot.v), @max(g.dirty[2], slot.u + bw), @max(g.dirty[3], slot.v + bh) };
g.shelf.x += bw + 1;
g.shelf.h = @max(g.shelf.h, bh + 1);
return slot;
}
/// Device pixels a canvas unit: the render scale (a supersampled target's
/// 4) times the window's logical presentation, if it is drawing there.
fn density(renderer: *c.SDL_Renderer) f32 {
var sx: f32 = 1;
var sy: f32 = 1;
_ = c.SDL_GetRenderScale(renderer, &sx, &sy);
var w: c_int = 0;
var h: c_int = 0;
var mode: c.SDL_RendererLogicalPresentation = undefined;
var rect: c.SDL_FRect = undefined;
if (c.SDL_GetRenderLogicalPresentation(renderer, &w, &h, &mode) and mode != c.SDL_LOGICAL_PRESENTATION_DISABLED and w > 0 and h > 0 and c.SDL_GetRenderLogicalPresentationRect(renderer, &rect)) {
sx *= rect.w / @as(f32, @floatFromInt(w));
sy *= rect.h / @as(f32, @floatFromInt(h));
}
return @max(0.25, @max(sx, sy));
}
test "the atlas's glyphs are pardes's: the same coverage bytes and the same place" {
const gpa = std.testing.allocator;
var g: Glyphs = .{ .gpa = gpa };
g.stage = try gpa.alloc(u8, side * side);
@memset(g.stage, 0);
defer g.deinit();
var compared: usize = 0;
var clipped: usize = 0;
// Grid faces (every advance the cell's) and a proportional one, which
// pardes centres in its cell.
for ([_]abi.Face{ .mono, .mono_bold, .mono_italic, .code, .code_medium, .sans }) |face| for ([_]f32{ 13, 19.5, 26, 52 }) |px| {
// pardes's Atlas over the same face: its own stage, its cells.
var pardes: Atlas = .{ .font = c.sk_text_ui(@backingInt(face)).?, .atlas_stage = try gpa.alloc(u8, side * side), .glyphs = .init(gpa) };
defer {
gpa.free(pardes.atlas_stage);
pardes.glyphs.deinit();
}
var cell_w: c_int = 0;
var height: c_int = 0;
var ascent: c_int = 0;
pardes.cellMetrics(px, &cell_w, &height, &ascent);
const body: Atlas.Size = .{ .px = px, .cell_w = @intCast(cell_w), .height = @intCast(height), .baseline = ascent };
pardes.reset(body.cell_w);
for (0x21..0x7f) |cp| {
const glyph = c.ui_font_glyph(pardes.font, @intCast(cp));
const ours = g.rasterize(.{ .face = @backingInt(face), .glyph = glyph, .px = @intFromFloat(px * 64) }).?;
// pardes centres the advance in its cell: nothing for a grid
// face, whose advances are all the cell's.
const shift = @divTrunc(cell_w - c.sk_text_advance(@backingInt(face), px, glyph), 2);
const x = shift + ours.dx;
const y = ascent + ours.dy;
// Ink pardes's cell cuts off is not comparable: count it.
if (x < 0 or y < 0 or x + ours.w > cell_w or y + ours.h > height) {
clipped += 1;
continue;
}
const at = pardes.cachedGlyph(.{ .face = 0, .glyph = glyph, .role = .body }, body, body, 1, 1).?;
const cell = pardes.atlas_stage[at.v * side + at.u ..];
const theirs = Atlas.inkBounds(cell, side, body.cell_w, body.height).?;
try std.testing.expectEqual(theirs.max_x - theirs.min_x + 1, ours.w);
try std.testing.expectEqual(theirs.max_y - theirs.min_y + 1, ours.h);
try std.testing.expectEqual(@as(i64, @intCast(theirs.min_x)), x);
try std.testing.expectEqual(@as(i64, @intCast(theirs.min_y)), y);
for (0..ours.h) |row| try std.testing.expectEqualSlices(u8, cell[(theirs.min_y + row) * side + theirs.min_x ..][0..ours.w], g.stage[(ours.v + row) * side + ours.u ..][0..ours.w]);
compared += 1;
}
};
// 6 faces at 4 sizes, 94 printable ASCII glyphs each: 2256, a few of
// which reach out of pardes's cell (`_` under it, `|` over it).
std.debug.print("pardes's raster: {d} glyphs equal byte for byte, {d} clipped by its cell\n", .{ compared, clipped });
try std.testing.expectEqual(@as(usize, 2256), compared + clipped);
try std.testing.expect(compared > 1900);
}
|