Files
faceclaw/scripts/test/build-evenhub-font.mjs

208 lines
8.3 KiB
JavaScript

#!/usr/bin/env node
/**
* Preprocess Even's extracted 20px firmware fonts into a single asset Faceclaw
* bundles and renders (app/fonts/evenhub/evenhub-20.json).
*
* Source: reverse-engineered LVGL lv_font_fmt_txt glyph data under
* g2/downloads/s200_embedded_fonts/{background_latin_20, background_greek_
* cyrillic_20, shared_emoji_20}. The Chinese font is intentionally excluded
* (we will substitute an OFL font for CJK later).
*
* Only glyph BITMAPS + boxes are taken from here; text SIZING/KERNING at
* runtime comes from @evenrealities/pretext, whose advance tables these
* bitmaps were cross-validated against. The three fonts are merged with the
* EvenHub fallback priority (latin > greek/cyrillic > emoji); the first font
* that owns a codepoint wins, matching pretext's chain.
*
* Bitmaps are 4bpp, high-nibble-first, row stride = floor(box_w/2)+1 (Even's
* pipeline pads every row by a nibble). The UI fonts are effectively 1-bit
* (nibbles are 0 or 0xF) but we keep 4bpp verbatim so any anti-aliasing
* survives.
*
* Output JSON:
* { lineHeight, baseline, glyphs: { "<cp>": [boxW, boxH, ofsX, ofsY, off, len] },
* bitmapBase64 }
* where off/len index the decoded bitmap blob. lineHeight/baseline come from
* the latin font (the layout reference; pretext uses the same 27px height).
*/
import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
import { dirname, join } from "node:path";
import { fileURLToPath } from "node:url";
const here = dirname(fileURLToPath(import.meta.url));
const FONT_SRC = join(here, "../../downloads/s200_embedded_fonts");
const OUT = join(here, "../app/fonts/evenhub/evenhub-20.json");
// Priority order = EvenHub fallback chain (minus cn).
const FONTS = ["background_latin_20", "background_greek_cyrillic_20", "shared_emoji_20"];
function rowStride(boxW) {
return Math.floor(boxW / 2) + 1;
}
const merged = new Map(); // codepoint -> {boxW,boxH,ofsX,ofsY,bytes:Uint8Array}
for (const font of FONTS) {
const dir = join(FONT_SRC, font);
const glyphs = JSON.parse(readFileSync(join(dir, "glyphs.json"), "utf8"));
const bitmap = readFileSync(join(dir, "glyph_bitmap.bin"));
for (const g of glyphs) {
if (g.codepoint === undefined) continue; // reserved / unmapped glyph slots
if (merged.has(g.codepoint)) continue; // earlier font in the chain wins
const len = g.box_height > 0 && g.box_width > 0 ? rowStride(g.box_width) * g.box_height : 0;
// Guard against the known slightly-truncated bitmap tails: pad short reads.
const bytes = new Uint8Array(len);
for (let i = 0; i < len; i++) bytes[i] = bitmap[g.bitmap_index + i] ?? 0;
merged.set(g.codepoint, {
boxW: g.box_width,
boxH: g.box_height,
ofsX: g.offset_x,
ofsY: g.offset_y,
bytes,
});
}
}
// Layout metrics from the latin font (also what pretext uses: 27px line).
const latinFont = JSON.parse(readFileSync(join(FONT_SRC, "background_latin_20", "manifest.json"), "utf8"));
const lineHeight = latinFont.line_height; // 27
const baseline = lineHeight - latinFont.base_line; // 27 - 5 = 22 (px below line top)
// ---------------------------------------------------------------------------
// Symbol / fullwidth glyphs from the CJK flash font (s200_font.bin).
//
// The three embedded UI fonts above cover latin/greek/emoji only, so grid-
// graphics apps come out blank: snake draws its board from U+3000 (ideographic
// space), U+25A6/U+25C6 (pieces) and fullwidth forms; block/box-drawing bars
// use U+2500-259F. Those glyphs live only in the SourceHanSans CJK font on the
// separate flash partition. We pull just the non-Han SYMBOL ranges from it
// (not the 21k ideographs — those wait for the OFL substitute) so grid UIs
// render. pretext already returns 20px advances for these, so only the bitmaps
// were missing. Format per notes/font-formats.txt (LVGL lv_font_fmt_txt in the
// "ZZZZ" flash wrapper, memory-mapped at 0x80100000).
const CJK_FONT = join(here, "../../downloads/s200_font.bin");
const CJK_MMAP_BASE = 0x80100000;
// Non-Han symbol ranges grid/graphics apps rely on (inclusive).
const SYMBOL_RANGES = [
[0x2000, 0x206f], // general punctuation (incl. various spaces/dashes)
[0x2100, 0x214f], // letterlike symbols (℃ ℉ №, etc.)
[0x2190, 0x21ff], // arrows
[0x2200, 0x22ff], // mathematical operators
[0x2500, 0x257f], // box drawing
[0x2580, 0x259f], // block elements
[0x25a0, 0x25ff], // geometric shapes (snake pieces)
[0x2600, 0x26ff], // miscellaneous symbols
[0x2700, 0x27bf], // dingbats
[0x3000, 0x303f], // CJK symbols & punctuation (ideographic space)
[0xff00, 0xffef], // halfwidth & fullwidth forms
];
function loadCjkSymbols(existing) {
let added = 0;
const cjk = readFileSync(CJK_FONT);
const off = (ptr) => ptr - CJK_MMAP_BASE;
const descPtr = cjk.readUInt32LE(0x34);
const cjkLineHeight = cjk.readUInt16LE(0x38);
const cjkBaseLine = cjk.readUInt16LE(0x3a);
const cjkBaseline = cjkLineHeight - cjkBaseLine; // 25 - 6 = 19
// Our single composite baseline differs, so shift ofsY to keep the glyph's
// designed vertical placement when drawn against our baseline.
const baselineShift = baseline - cjkBaseline;
let d = off(descPtr);
const glyphBitmapOff = off(cjk.readUInt32LE(d));
const glyphDscOff = off(cjk.readUInt32LE(d + 4));
const cmapOff = off(cjk.readUInt32LE(d + 8));
// kerning ptr (d+12) is null; packed field after gives cmap_num.
const packed = cjk.readUInt16LE(d + 18);
const cmapNum = packed & 0x1ff;
// Parse the cmap table into lookup records.
const cmaps = [];
for (let i = 0; i < cmapNum; i++) {
const base = cmapOff + i * 20;
cmaps.push({
rangeStart: cjk.readUInt32LE(base),
rangeLength: cjk.readUInt16LE(base + 4),
glyphIdStart: cjk.readUInt16LE(base + 6),
unicodeListPtr: cjk.readUInt32LE(base + 8),
glyphIdOfsListPtr: cjk.readUInt32LE(base + 12),
listLength: cjk.readUInt16LE(base + 16),
type: cjk.readUInt8(base + 18),
});
}
const glyphIdFor = (cp) => {
for (const c of cmaps) {
if (cp < c.rangeStart || cp >= c.rangeStart + c.rangeLength) continue;
const rel = cp - c.rangeStart;
if (c.type === 2) return c.glyphIdStart + rel; // contiguous
if (c.type === 0) {
// u8 glyph-id-offset array
return c.glyphIdStart + cjk.readUInt8(off(c.glyphIdOfsListPtr) + rel);
}
if (c.type === 3) {
// sparse: u16 unicode-delta list; index in the list is the glyph offset
const listOff = off(c.unicodeListPtr);
for (let k = 0; k < c.listLength; k++) {
if (cjk.readUInt16LE(listOff + k * 2) === rel) {
const gid = c.glyphIdOfsListPtr
? cjk.readUInt8(off(c.glyphIdOfsListPtr) + k)
: k;
return c.glyphIdStart + gid;
}
}
return 0;
}
}
return 0;
};
for (const [start, end] of SYMBOL_RANGES) {
for (let cp = start; cp <= end; cp++) {
if (existing.has(cp)) continue; // don't override latin/greek/emoji
const gid = glyphIdFor(cp);
if (!gid) continue;
const dsc = glyphDscOff + gid * 16;
const bitmapIndex = cjk.readUInt32LE(dsc);
const boxW = cjk.readUInt16LE(dsc + 8);
const boxH = cjk.readUInt16LE(dsc + 10);
const ofsX = cjk.readInt16LE(dsc + 12);
const ofsY = cjk.readInt16LE(dsc + 14);
const len = boxW > 0 && boxH > 0 ? rowStride(boxW) * boxH : 0;
const bytes = new Uint8Array(len);
for (let i = 0; i < len; i++) bytes[i] = cjk[glyphBitmapOff + bitmapIndex + i] ?? 0;
existing.set(cp, { boxW, boxH, ofsX, ofsY: ofsY + baselineShift, bytes });
added++;
}
}
return added;
}
const cjkAdded = loadCjkSymbols(merged);
// Concatenate bitmaps and record offsets.
const chunks = [];
let offset = 0;
const glyphRecords = {};
for (const [cp, g] of [...merged].sort((a, b) => a[0] - b[0])) {
chunks.push(g.bytes);
glyphRecords[cp] = [g.boxW, g.boxH, g.ofsX, g.ofsY, offset, g.bytes.length];
offset += g.bytes.length;
}
const blob = Buffer.concat(chunks.map((c) => Buffer.from(c)));
const asset = {
lineHeight,
baseline,
glyphs: glyphRecords,
bitmapBase64: blob.toString("base64"),
};
mkdirSync(dirname(OUT), { recursive: true });
writeFileSync(OUT, JSON.stringify(asset));
console.log(
`wrote ${OUT}: ${merged.size} glyphs (${cjkAdded} from CJK symbols), ` +
`${blob.length} bitmap bytes, ${(JSON.stringify(asset).length / 1024).toFixed(1)} KiB json`,
);