martino/plotter
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
5ca35873255f96e4dccc880f538d4463b4312ec5
plotter/tools/fonts/gen_atlas.py
T

646 lines
26 KiB
Python
Executable File
Raw Blame History

#!/usr/bin/env python3
"""Bake the embedded mono font's anti-aliased atlas, at authoring time.
Reads a TrueType/OpenType file and writes a C++ translation unit holding a
greyscale coverage atlas, one fixed cell per glyph, plus the per-glyph rect,
bearing and advance table the text pipeline stages from.
tools/fonts/gen_atlas.py [--font PATH] [--em N] [--supersample N] [--out PATH] [--check]
This is an **authoring-time** tool. `plot_core` and every public header under
`include/plot/` stay third-party-free: nothing here runs at build time, the
atlas is committed as data, and `fontTools` is never needed to compile or run the
library. Regenerating is a deliberate act followed by a commit.
Rasterisation is ours, not a rasteriser's: the glyph outlines are flattened with
`fontTools.pens`, scanline-filled at `supersample` times the em, and box-filtered
down to one coverage byte per texel. Nothing shells out.
Determinism
-----------
Same font file plus the same em size and supersample factor must produce a
byte-identical translation unit -- `--check` depends on it, and so does a
reviewable diff. Everything emitted is derived from integers (cell geometry, the
font's own advance units) or from a fixed, sorted walk of the coverage list; no
timestamp, no set/dict iteration order, no float formatting, no host path beyond
the source font's file name.
Blank ink is a hard failure
---------------------------
Every requested codepoint must rasterise to at least one inked texel. A silent
blank cell is exactly the failure that makes a font swap look like it worked, so
the generator exits non-zero instead. The single documented exception is U+0020,
which is blank *by definition* -- an intentional blank with a full advance.
Provenance
----------
The default face is Adwaita Mono, `AdwaitaMono-Regular.ttf`, released under the
SIL Open Font License 1.1 (a copy is committed at `licences/OFL-1.1.txt`). The
backend is named neutrally (`EmbeddedMonoFont`) because OFL reserves the font
name for modified redistributions. The generated file records the source file
name, the font's own name/version strings, the em size, the supersample factor
and the exact coverage set.
"""
from __future__ import annotations
import argparse
import math
import os
import sys
from pathlib import Path
DEFAULT_FONT = "/usr/share/fonts/Adwaita/AdwaitaMono-Regular.ttf"
DEFAULT_EM = 13
DEFAULT_SUPERSAMPLE = 4
DEFAULT_OUT = "src/render/embedded_mono_font.cpp"
SCRIPT = "tools/fonts/gen_atlas.py"
# The fallback box, in font units with the origin at the pen on the baseline, y up
# like the outlines it stands in for. Its two contours wind oppositely, so the
# non-zero fill leaves a hollow box: an outer rectangle and an inner hole, each
# stroke 100 units (1.3 px at 13 px em). It is authored here, not taken from the
# font -- it is what an uncovered codepoint draws.
FALLBACK_OUTER = ((60.0, -100.0), (580.0, -100.0), (580.0, 700.0), (60.0, 700.0))
FALLBACK_INNER = ((160.0, 0.0), (160.0, 600.0), (480.0, 600.0), (480.0, 0.0))
# The codepoint side of the coverage set: printable ASCII, the three codepoints
# `plot::format_si` emits, and the two dashes a plotting label uses. The fallback
# slot is appended after them.
ASCII = list(range(0x20, 0x7F))
SPECIALS = [0xB0, 0xB5, 0x03A9, 0x2013, 0x2014]
FALLBACK_CODEPOINT = 0xFFFFFFFF # not a Unicode scalar; cannot collide
# Sub-curve flattening steps. Fixed, not tolerance-adaptive: at a 13 px em they
# are far below one supersampled texel even at 4x, and a constant keeps the
# output independent of anything but the font file.
QUAD_STEPS = 12
CUBIC_STEPS = 16
EXIT_OK = 0
EXIT_MISMATCH = 1
EXIT_BAD_FONT = 2
EXIT_NO_FONTTOOLS = 3
def _fail(code: int, message: str) -> int:
print(f"{SCRIPT}: {message}", file=sys.stderr)
return code
def _require_fonttools():
try:
from fontTools.pens.basePen import BasePen # noqa: F401
from fontTools.ttLib import TTFont # noqa: F401
except ImportError:
raise SystemExit(
_fail(
EXIT_NO_FONTTOOLS,
"fontTools is not installed; this is an authoring-time tool. "
"Install it (pip install fonttools) to regenerate the atlas.",
)
)
def _contour_pen_class():
from fontTools.pens.basePen import BasePen
class ContourPen(BasePen):
"""Flattens one glyph to contour point lists in cell space.
`xf` maps a font-unit point (y up, origin at the pen on the baseline) to
supersampled cell coordinates (y down, origin at the cell's top-left),
so every geometric decision below is made once, here.
"""
def __init__(self, glyph_set, xf):
super().__init__(glyph_set)
self._xf = xf
self.contours = []
self._current = []
def _map(self, point):
return self._xf(point[0], point[1])
def _moveTo(self, pt):
self._current = [self._map(pt)]
def _lineTo(self, pt):
self._current.append(self._map(pt))
def _qCurveToOne(self, control, point):
p0 = self._current[-1]
p1 = self._map(control)
p2 = self._map(point)
for step in range(1, QUAD_STEPS + 1):
t = step / QUAD_STEPS
u = 1.0 - t
self._current.append(
(
u * u * p0[0] + 2.0 * u * t * p1[0] + t * t * p2[0],
u * u * p0[1] + 2.0 * u * t * p1[1] + t * t * p2[1],
)
)
def _curveToOne(self, c1, c2, point):
p0 = self._current[-1]
p1 = self._map(c1)
p2 = self._map(c2)
p3 = self._map(point)
for step in range(1, CUBIC_STEPS + 1):
t = step / CUBIC_STEPS
u = 1.0 - t
b0 = u * u * u
b1 = 3.0 * u * u * t
b2 = 3.0 * u * t * t
b3 = t * t * t
self._current.append(
(
b0 * p0[0] + b1 * p1[0] + b2 * p2[0] + b3 * p3[0],
b0 * p0[1] + b1 * p1[1] + b2 * p2[1] + b3 * p3[1],
)
)
def _closePath(self):
if len(self._current) >= 3:
self.contours.append(self._current)
self._current = []
def _endPath(self):
self._closePath()
return ContourPen
def _scanline_mask(contours, width, height):
"""Non-zero-winding scanline fill of `contours` into a `height` x `width` 0/1 grid.
The fill rule is non-zero rather than even-odd because TrueType orients a
hole opposite its outer contour and a font is entitled to overlapping
contours; even-odd would punch a hole out of any overlap.
"""
mask = [[0] * width for _ in range(height)]
edges = []
for contour in contours:
count = len(contour)
for i in range(count):
x0, y0 = contour[i]
x1, y1 = contour[(i + 1) % count]
if y0 != y1:
edges.append((x0, y0, x1, y1))
for row in range(height):
yc = row + 0.5
crossings = []
for x0, y0, x1, y1 in edges:
if (y0 <= yc) != (y1 <= yc):
t = (yc - y0) / (y1 - y0)
crossings.append((x0 + t * (x1 - x0), 1 if y1 > y0 else -1))
if not crossings:
continue
crossings.sort()
winding = 0
span_start = 0.0
for x, direction in crossings:
previous = winding
winding += direction
if previous == 0 and winding != 0:
span_start = x
elif previous != 0 and winding == 0:
first = max(0, int(math.ceil(span_start - 0.5)))
last = min(width, int(math.floor(x - 0.5)) + 1)
target = mask[row]
for column in range(first, last):
target[column] = 1
return mask
def _coverage_cell(contours, cell_w, cell_h, supersample):
"""Box-filter `contours` into `cell_h` rows of `cell_w` coverage bytes.
`contours` are in supersampled cell space, so each output texel averages the
`supersample` x `supersample` sub-samples that land on it -- a plain coverage
count, which is what makes the result greyscale.
"""
area = supersample * supersample
mask = _scanline_mask(contours, cell_w * supersample, cell_h * supersample)
rows = []
for ty in range(cell_h):
row = []
for tx in range(cell_w):
covered = 0
for sy in range(supersample):
sub = mask[ty * supersample + sy]
base = tx * supersample
for sx in range(supersample):
covered += sub[base + sx]
# Round-half-up in integers: deterministic, and independent of the
# host's floating-point formatting.
row.append((covered * 255 + area // 2) // area)
rows.append(row)
return rows
def _cell_transform(em, units_per_em, ascent_px, supersample):
scale = em / units_per_em
def xf(x_units, y_units):
return (x_units * scale * supersample, (ascent_px - y_units * scale) * supersample)
return xf
def _read_font(path):
from fontTools.ttLib import TTFont
if not os.path.isfile(path):
raise SystemExit(_fail(EXIT_BAD_FONT, f"no such font file: {path}"))
try:
return TTFont(path, recalcBBoxes=False, recalcTimestamp=False)
except Exception as exc: # fontTools raises a spread of parser errors
raise SystemExit(_fail(EXIT_BAD_FONT, f"cannot parse {path}: {exc}"))
def build(font_path, em, supersample):
"""Rasterise the coverage set at `em` px; returns the geometry and cells."""
font = _read_font(font_path)
head = font["head"]
os2 = font["OS/2"]
units_per_em = head.unitsPerEm
glyph_set = font.getGlyphSet()
cmap = font.getBestCmap()
hmtx = font["hmtx"]
name_record = font["name"]
def name(identifier, fallback):
value = name_record.getDebugName(identifier)
return value if value else fallback
scale = em / units_per_em
ascent_units = os2.sTypoAscender
descent_units = -os2.sTypoDescender
ascent_px = ascent_units * scale
contours_class = _contour_pen_class()
from fontTools.pens.boundsPen import BoundsPen
codepoints = list(ASCII) + list(SPECIALS)
# The cell: wide enough for the widest advance (the pen must never leave the
# cell) and for the widest ink; tall enough for the face's ascent-to-descent
# extent. Never trimmed to any one glyph's ink -- a fixed-cell grid is what
# lets the pipeline carry one rect size per draw.
widest_advance = 0
widest_ink = 0.0
for codepoint in codepoints:
glyph_name = cmap.get(codepoint)
if glyph_name is None:
raise SystemExit(
_fail(EXIT_BAD_FONT, f"{font_path} has no glyph for U+{codepoint:04X}")
)
advance, _bearing = hmtx[glyph_name]
widest_advance = max(widest_advance, advance)
bounds = BoundsPen(glyph_set)
glyph_set[glyph_name].draw(bounds)
if bounds.bounds is not None:
widest_ink = max(widest_ink, bounds.bounds[2])
cell_w = int(math.ceil(max(widest_advance * scale, widest_ink * scale) - 1e-9))
cell_h = int(math.ceil(ascent_px + descent_units * scale - 1e-9))
if cell_w <= 0 or cell_h <= 0:
raise SystemExit(_fail(EXIT_BAD_FONT, "the computed cell is empty"))
xf = _cell_transform(em, units_per_em, ascent_px, supersample)
cells = []
advances = []
for codepoint in codepoints:
glyph_name = cmap[codepoint]
pen = contours_class(glyph_set, xf)
glyph_set[glyph_name].draw(pen)
rows = _coverage_cell(pen.contours, cell_w, cell_h, supersample)
ink = sum(sum(row) for row in rows)
if codepoint != 0x20 and ink == 0:
# A silent blank cell is the failure mode this whole exercise exists
# to remove: refuse to ship it.
raise SystemExit(
_fail(
EXIT_BAD_FONT,
f"U+{codepoint:04X} ({glyph_name}) rasterised to no ink at "
f"{em} px; the cell is too small or the glyph is missing",
)
)
cells.append(rows)
advances.append(hmtx[glyph_name][0])
fallback_pen = contours_class(glyph_set, xf)
fallback_pen.contours = [
[fallback_pen._xf(x, y) for x, y in FALLBACK_OUTER],
[fallback_pen._xf(x, y) for x, y in FALLBACK_INNER],
]
fallback_rows = _coverage_cell(fallback_pen.contours, cell_w, cell_h, supersample)
if sum(sum(row) for row in fallback_rows) == 0:
raise SystemExit(_fail(EXIT_BAD_FONT, "the fallback box rasterised to no ink"))
cells.append(fallback_rows)
advances.append(widest_advance)
geometry = {
"em": em,
"supersample": supersample,
"units_per_em": units_per_em,
"scale": scale,
"ascent_units": ascent_units,
"descent_units": descent_units,
"ascent_px": ascent_px,
"cell_w": cell_w,
"cell_h": cell_h,
"glyph_count": len(codepoints) + 1,
"fallback_slot": len(codepoints),
"codepoints": codepoints,
"advances": advances,
"cells": cells,
}
provenance = {
"font_file": os.path.basename(font_path),
"font_name": name(4, "unknown"),
"font_version": name(5, "unknown"),
}
font.close()
return geometry, provenance
def _codepoint_label(codepoint):
if codepoint == FALLBACK_CODEPOINT:
return "fallback box"
return f"U+{codepoint:04X}"
def emit(geometry, provenance):
"""Render one `build()` result as the generated translation unit."""
em = geometry["em"]
supersample = geometry["supersample"]
units_per_em = geometry["units_per_em"]
cell_w = geometry["cell_w"]
cell_h = geometry["cell_h"]
glyph_count = geometry["glyph_count"]
fallback_slot = geometry["fallback_slot"]
atlas_w = cell_w * glyph_count
atlas_h = cell_h
codepoints = geometry["codepoints"]
advances = geometry["advances"]
slot_codepoints = list(codepoints) + [FALLBACK_CODEPOINT]
ascii_lo = ASCII[0]
ascii_hi = ASCII[-1]
lines = []
add = lines.append
add("// GENERATED FILE -- do not edit by hand.")
add("//")
add(f"// Regenerate with: {SCRIPT}")
add(f"// The generator takes the source font, the em size and the supersample factor;")
add(f"// its defaults bake the face this file holds. `{SCRIPT} --check`")
add("// regenerates into memory and fails if this file has drifted from its input.")
add("//")
add("// Provenance")
add("// source font : " + provenance["font_file"])
add("// font name : " + provenance["font_name"])
add("// font version : " + provenance["font_version"])
add("// licence : SIL Open Font License 1.1 (licences/OFL-1.1.txt)")
add(f"// units per em : {units_per_em}")
add(f"// em size : {em} px")
add(f"// supersample : {supersample}x ({supersample * supersample} samples per texel)")
add(f"// coverage : U+{ascii_lo:04X}..U+{ascii_hi:04X}, "
+ ", ".join(f"U+{cp:04X}" for cp in SPECIALS)
+ ", plus a fallback box")
add(f"// cell : {cell_w} x {cell_h} texels, one row of {glyph_count}")
add(f"// atlas : {atlas_w} x {atlas_h} texels")
add("//")
add("// The cell is the face's maximum advance wide and its ascent-to-descent extent")
add("// tall; every glyph is drawn into that cell with its bearing preserved, never")
add("// trimmed to its ink, because the pipeline stages one rect *origin* per glyph and")
add("// carries one rect *size* for the whole draw (see render::TextBackend::cell_uv).")
add("// Coverage is a plain supersampled coverage count, so a stroke's edges are grey")
add("// and not a 1-bit threshold.")
add("")
add("#include <plot/render/embedded_mono_font.hpp>")
add("")
add("#include <array>")
add("#include <utility>")
add("")
add("namespace plot::render {")
add("namespace {")
add("")
add("// Geometry, all of it derived from the bake above by the generator.")
add(f"constexpr u32 kEmPx = {em}u;")
add(f"constexpr u32 kSupersample = {supersample}u;")
add(f"constexpr u32 kUnitsPerEm = {units_per_em}u;")
add(f"constexpr u32 kCellW = {cell_w}u;")
add(f"constexpr u32 kCellH = {cell_h}u;")
add(f"constexpr u32 kGlyphCount = {glyph_count}u;")
add(f"constexpr u32 kFallbackSlot = {fallback_slot}u;")
add("constexpr u32 kAtlasW = kCellW * kGlyphCount;")
add("constexpr u32 kAtlasH = kCellH;")
add("constexpr u32 kAsciiFirst = " + f"{ascii_lo}u;")
add("constexpr u32 kAsciiGlyphs = " + f"{len(ASCII)}u;")
add("constexpr u32 kFallbackCodepoint = " + f"0x{FALLBACK_CODEPOINT:08X}u;")
add("")
add(f"constexpr u32 kAscentUnits = {geometry['ascent_units']}u;")
add("// Font pixels per font unit. The one non-integer factor, and the only place a")
add("// float enters: everything else here is an integer.")
add("constexpr f32 kScale = static_cast<f32>(kEmPx) / static_cast<f32>(kUnitsPerEm);")
add("constexpr f32 kAscentPx = static_cast<f32>(kAscentUnits) * kScale;")
add("")
add("// The public header repeats the em size, the supersample factor and the")
add("// fallback marker so a caller can read them without opening this table.")
add("// These asserts are what make that a pin and not a copy: re-baking at another")
add("// em or supersample factor, or moving the fallback marker, fails to compile")
add("// until the header agrees, so the two can never silently disagree.")
add("static_assert(kEmPx == EmbeddedMonoFont::kEmPx,")
add(" \"embedded_mono_font.hpp kEmPx disagrees with the bake\");")
add("static_assert(kSupersample == EmbeddedMonoFont::kSupersample,")
add(" \"embedded_mono_font.hpp kSupersample disagrees with the bake\");")
add("static_assert(kFallbackCodepoint == EmbeddedMonoFont::kFallbackCodepoint,")
add(" \"embedded_mono_font.hpp kFallbackCodepoint disagrees with the bake\");")
add("")
add("/// The codepoint each slot was baked for, in slot order; the fallback slot")
add("/// carries `kFallbackCodepoint`, which is not a Unicode scalar.")
add(f"constexpr u32 kCodepoints[kGlyphCount] = {{")
for slot, codepoint in enumerate(codepoints):
add(f" 0x{codepoint:04X}u, // [{slot:3d}] {_codepoint_label(codepoint)}")
add(f" 0x{FALLBACK_CODEPOINT:08X}u, // [{fallback_slot:3d}] {_codepoint_label(FALLBACK_CODEPOINT)}")
add("};")
add("")
add("/// The advance each slot contributes to the pen, in font units. The face is")
add("/// monospaced, so these are all equal -- but the table is per glyph, because the")
add("/// advance is the font's own `hmtx` value and not an assumption about the face.")
add(f"constexpr u32 kAdvanceUnits[kGlyphCount] = {{")
for slot, advance in enumerate(advances):
codepoint = codepoints[slot] if slot < len(codepoints) else FALLBACK_CODEPOINT
add(f" {advance}u, // [{slot:3d}] {_codepoint_label(codepoint)}")
add("};")
add("")
add("/// The packed atlas: one row of cells, top row first, straight coverage, 0 for")
add("/// background and 255 for full ink. GL_R8-ready, no dilation, no gamma.")
add(f"constexpr u8 kAtlas[kAtlasW * kAtlasH] = {{")
for row in range(atlas_h):
for slot in range(glyph_count):
values = geometry["cells"][slot][row]
body = ", ".join(f"0x{value:02X}" for value in values)
label = _codepoint_label(slot_codepoints[slot])
add(f" {body}, // [{slot:3d}] {label} row {row:2d}")
add("};")
add("")
add("/// One slot's glyph: the cell it occupies in the atlas, drawn from the cell's")
add("/// top-left (the pen) with no extra bearing -- the bearing is baked into the")
add("/// cell's ink -- and the advance the pen moves by.")
add("constexpr Glyph make_glyph(u32 slot) noexcept {")
add(" const f32 u0 = static_cast<f32>(slot * kCellW) / static_cast<f32>(kAtlasW);")
add(" const f32 du = static_cast<f32>(kCellW) / static_cast<f32>(kAtlasW);")
add(" const f32 dv = static_cast<f32>(kCellH) / static_cast<f32>(kAtlasH);")
add(" return Glyph{u0, 0.0f, u0 + du, dv, 0.0f, 0.0f,")
add(" static_cast<f32>(kAdvanceUnits[slot]) * kScale};")
add("}")
add("")
add("template <u32... Slots>")
add("constexpr std::array<Glyph, sizeof...(Slots)> make_glyphs(")
add(" std::integer_sequence<u32, Slots...>) noexcept {")
add(" return {make_glyph(Slots)...};")
add("}")
add("")
add("constexpr std::array<Glyph, kGlyphCount> kGlyphs =")
add(" make_glyphs(std::make_integer_sequence<u32, kGlyphCount>{});")
add("")
add("} // namespace")
add("")
add("u32 EmbeddedMonoFont::glyph_index(u32 codepoint) noexcept {")
add(" if (codepoint >= kAsciiFirst && codepoint < kAsciiFirst + kAsciiGlyphs) {")
add(" return codepoint - kAsciiFirst;")
add(" }")
add(" switch (codepoint) {")
for offset, codepoint in enumerate(SPECIALS):
add(f" case 0x{codepoint:04X}u:")
add(f" return kAsciiGlyphs + {offset}u;")
add(" default:")
add(" return kFallbackSlot;")
add(" }")
add("}")
add("")
add("f32 EmbeddedMonoFont::advance_codepoint(u32 codepoint) noexcept {")
add(" return static_cast<f32>(kAdvanceUnits[glyph_index(codepoint)]) * kScale;")
add("}")
add("")
add("f32 EmbeddedMonoFont::measure(const char* utf8) const {")
add(" if (utf8 == nullptr) {")
add(" return 0.0f;")
add(" }")
add(" f32 width = 0.0f;")
add(" for (const char* p = utf8; *p != '\\0';) {")
add(" width += advance_codepoint(next_codepoint(p));")
add(" }")
add(" return width;")
add("}")
add("")
add("f32 EmbeddedMonoFont::height() const { return static_cast<f32>(kCellH); }")
add("")
add("f32 EmbeddedMonoFont::ascent() const { return kAscentPx; }")
add("")
add("f32 EmbeddedMonoFont::em_px() const { return static_cast<f32>(kEmPx); }")
add("")
add("const Glyph* EmbeddedMonoFont::glyph(u32 codepoint) const {")
add(" return &kGlyphs[glyph_index(codepoint)];")
add("}")
add("")
add("Vec2 EmbeddedMonoFont::cell_uv() const {")
add(" return Vec2{static_cast<f32>(kCellW) / static_cast<f32>(kAtlasW),")
add(" static_cast<f32>(kCellH) / static_cast<f32>(kAtlasH)};")
add("}")
add("")
add("const u8* EmbeddedMonoFont::atlas_pixels() const { return kAtlas; }")
add("")
add("u32 EmbeddedMonoFont::atlas_width() const { return kAtlasW; }")
add("")
add("u32 EmbeddedMonoFont::atlas_height() const { return kAtlasH; }")
add("")
add("u32 EmbeddedMonoFont::revision() const { return 0u; }")
add("")
add("u32 EmbeddedMonoFont::glyph_count() noexcept { return kGlyphCount; }")
add("")
add("u32 EmbeddedMonoFont::codepoint_of_slot(u32 slot) noexcept {")
add(" return slot < kGlyphCount ? kCodepoints[slot] : kFallbackCodepoint;")
add("}")
add("")
add("u32 EmbeddedMonoFont::cell_width() noexcept { return kCellW; }")
add("")
add("u32 EmbeddedMonoFont::cell_height() noexcept { return kCellH; }")
add("")
add("Vec2 EmbeddedMonoFont::atlas_origin(u32 slot) noexcept {")
add(" const u32 s = slot < kGlyphCount ? slot : kFallbackSlot;")
add(" return Vec2{static_cast<f32>(s * kCellW), 0.0f};")
add("}")
add("")
add("const u8* EmbeddedMonoFont::atlas_image() noexcept { return kAtlas; }")
add("")
add("} // namespace plot::render")
add("")
return "\n".join(lines)
def generate(font_path, em, supersample):
geometry, provenance = build(font_path, em, supersample)
return emit(geometry, provenance), geometry
def main(argv=None):
parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
parser.add_argument("--font", default=DEFAULT_FONT, help="source TrueType/OpenType file")
parser.add_argument("--em", type=int, default=DEFAULT_EM, help="em size in pixels")
parser.add_argument(
"--supersample", type=int, default=DEFAULT_SUPERSAMPLE, help="coverage samples per texel"
)
parser.add_argument("--out", default=DEFAULT_OUT, help="translation unit to write")
parser.add_argument(
"--check",
action="store_true",
help="regenerate and fail if the committed file differs, instead of writing",
)
args = parser.parse_args(argv)
if args.em <= 0 or args.supersample <= 0:
return _fail(EXIT_BAD_FONT, "em size and supersample factor must be positive")
_require_fonttools()
if args.check:
out = Path(args.out)
committed = out.read_bytes() if out.is_file() else None
fresh, _ = generate(args.font, args.em, args.supersample)
if committed is None:
return _fail(EXIT_MISMATCH, f"{out} does not exist; run {SCRIPT} to generate it")
if committed != fresh.encode():
return _fail(
EXIT_MISMATCH,
f"{out} differs from a fresh bake; regenerate with {SCRIPT} and commit the result",
)
print(f"{SCRIPT}: {out} matches a fresh bake", file=sys.stderr)
return EXIT_OK
text, geometry = generate(args.font, args.em, args.supersample)
Path(args.out).write_bytes(text.encode())
ink = sum(sum(row) for cell in geometry["cells"] for row in cell)
print(
f"{SCRIPT}: {args.out}: {geometry['glyph_count']} glyphs, "
f"cell {geometry['cell_w']}x{geometry['cell_h']}, "
f"atlas {geometry['cell_w'] * geometry['glyph_count']}x{geometry['cell_h']}, "
f"{args.em} px em, {args.supersample}x, {ink} ink units",
file=sys.stderr,
)
return EXIT_OK
if __name__ == "__main__":
raise SystemExit(main())
Reference in new issue View Git Blame Copy Permalink