From 303478956e0086467a9073d7f6fa67b51b6580ad Mon Sep 17 00:00:00 2001 From: Gabriel Schneider Date: Tue, 17 Nov 2026 09:06:20 -0300 Subject: text: sk.text measures anywhere, Frame.paragraph wraps, aligns, spans, reveals and finds a caret The ABI's one text entry is textRun (Host.VTable.textSize goes): a run in a face at a scale, as data, its advance and line box and each byte's x, a pure function of the font, the scale and the bytes, never of the display; and font, a face for a sketch's own TTF/OTF bytes (abi.Face is non-exhaustive: faces past the ten are a sketch's). The native host serves them from vendor/text.c (sk_text_run, sk_text_font), the web host from canvas measureText and FontFace (web/host.js), and the web draws each run in the page's monospace or sans-serif in the face's weight and style instead of 8 px a character. src/sketch/text.zig (sk.text) does the rest in plain Zig, the same on every host: size, layout and font anywhere, update included (the glue sets the host before each call into the sketch; a test binary has none and calls sketchbook-text directly, which App.addTest now links); a Paragraph is a face, scale and colour, a width to wrap at spaces, an alignment, spans (from a byte on: a colour, a face, a scale), reveal (the first N glyphs drawn, the layout the whole text's) and a caret byte, and its Layout the size, lines, glyphs and the caret's place. f.paragraph draws one, a Command.text a piece. f.text, f.textIn and f.print are a paragraph with no width when the bytes hold a \n, else the one command they were; host.textSize and textSizeIn stay, one line through textRun. Test: sk.text's own tests (a wrap, the space not counted, centred and right, a caret at a line's start and end and after a \n, a span twice the size, a word wider than the width, an empty text; reveal drawing the first glyphs of the same layout), run through sketchbook-text; and test/text.zig draws a centred paragraph with a red and a double-size span and a caret from its Layout, which test/text.script pins. zig build test-text runs these and the atlas's comparison with pardes's raster. Every other pinned pixel of test/text.script holds: the lines it pins are the same pixels Pango drew. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T --- web/host.js | 53 +++++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 47 insertions(+), 6 deletions(-) (limited to 'web') diff --git a/web/host.js b/web/host.js index 32bdbfb..8213dbd 100644 --- a/web/host.js +++ b/web/host.js @@ -519,8 +519,49 @@ function drawImage(id, x, y, w, h, sx, sy, sw, sh, r, g, b, a, place) { ctx.restore(); } +// Text (docs/text.md): sketchbook's faces in the page's fonts, in their +// weight and style, and a sketch's own font a FontFace (`fonts`, its bytes +// kept to give the same face for the same bytes). 13 px at scale 1. +const faceFonts = [['', 'monospace'], ['bold', 'monospace'], ['italic', 'monospace'], ['', 'sans-serif'], ['500', 'sans-serif'], ['bold', 'sans-serif'], ['', 'monospace'], ['bold', 'monospace'], ['italic', 'monospace'], ['500', 'monospace']]; +const fonts = []; +const fontOf = (face, scale) => { + const [style, family] = face < 10 ? faceFonts[face] : ['', fonts[face - 10]?.family ?? 'monospace']; + return `${style} ${13 * scale}px ${family}`.trim(); +}; +const measurer = document.createElement('canvas').getContext('2d'); + const imports = { host: { + // A run's width, ascent and line height, and each byte's x (a byte inside + // a codepoint at its codepoint's): the prefixes measured, so drawn is + // measured, kerning included. + textRun(face, scale, ptr, len, xsPtr, xsLen, outPtr) { + measurer.font = fontOf(face, scale); + const all = bytes(ptr, len).slice(); + const m = measurer.measureText(decoder.decode(all)); + new Float32Array(wasm.memory.buffer, outPtr, 3).set([m.width, m.fontBoundingBoxAscent, m.fontBoundingBoxAscent + m.fontBoundingBoxDescent]); + if (!xsLen) return; + const xs = new Float32Array(wasm.memory.buffer, xsPtr, xsLen); + let x = 0; + for (let i = 0; i < len; i++) { + if ((all[i] & 0xc0) !== 0x80) x = i ? measurer.measureText(decoder.decode(all.subarray(0, i))).width : 0; + xs[i] = x; + } + }, + font(ptr, len) { + const data = bytes(ptr, len).slice(); + const known = fonts.findIndex(f => f.data.length === data.length && f.data.every((b, i) => b === data[i])); + if (known >= 0) return 10 + known; + if (fonts.length === 54) return -1; + const family = `sketchbook-font-${fonts.length}`; + try { + const face = new FontFace(family, data); + document.fonts.add(face); + face.load().catch(err => console.warn(`font ${family}: ${err}`)); + } catch { return -1; } + fonts.push({family, data}); + return 10 + fonts.length - 1; + }, log(ptr, len) { console.log(string(ptr, len)); }, loadImage(ptr, len) { const path = string(ptr, len); @@ -615,15 +656,15 @@ const imports = { if (open) ctx.fill('nonzero'); }, // Always blended alpha, as native text is. - text(x, y, scale, ptr, len, r, g, b, a) { + // A run from its line box's top left, in the face textRun measures it in. + text(x, y, scale, face, ptr, len, r, g, b, a) { ctx.save(); ctx.globalCompositeOperation = 'source-over'; ctx.fillStyle = rgba(r, g, b, a); - // The native font is a fixed 8px cell: the same advance, and a size - // whose capitals fill the cell as native ones do. - ctx.font = `${10 * scale}px monospace`; - ctx.textBaseline = 'top'; - for (const [i, ch] of Array.from(string(ptr, len)).entries()) ctx.fillText(ch, x + i * 8 * scale, y); + ctx.font = fontOf(face, scale); + ctx.textBaseline = 'alphabetic'; + const s = string(ptr, len); + ctx.fillText(s, x, y + ctx.measureText(s).fontBoundingBoxAscent); ctx.restore(); }, clip(enabled, x, y, w, h) { -- cgit v1.3