Add pixel font, wrapping and micro font
This commit is contained in:
8 files changed
+862
-1
No files matched your search
@@ -9,7 +9,7 @@ Progress truth: `TASKS.md`. Requirements: `PRD.md` and `docs/prd/components-*.md
|
|||||||
| --- | --- |
|
| --- | --- |
|
||||||
| Go | 1.27.1 |
|
| Go | 1.27.1 |
|
||||||
| MyGo | `github.com/egoist/mygo v0.2.10`, pinned in go.mod |
|
| MyGo | `github.com/egoist/mygo v0.2.10`, pinned in go.mod |
|
||||||
| Font | Ark Pixel Font 12px proportional zh_Hans (OFL-1.1), packed into `pixel/font12.bin` by `tools/fontpack` |
|
| Font | Ark Pixel Font 12px proportional zh_Hans v2026.09.25 (OFL-1.1, `pixel/OFL.txt`). Rebuild: `go run ./tools/fontpack -in ark-pixel-12px-proportional-zh_hans.bdf` (BDF sha256 `535f7024…8c86`) |
|
||||||
| Web | `cmd/web` built with `GOOS=js GOARCH=wasm`; the browser runs the gallery under `ui.Tester` and blits frames to a canvas |
|
| Web | `cmd/web` built with `GOOS=js GOARCH=wasm`; the browser runs the gallery under `ui.Tester` and blits frames to a canvas |
|
||||||
| Hosting | Cloudflare Workers static assets from `web/dist`; code on Gitea `git.zacharyzhang.com` |
|
| Hosting | Cloudflare Workers static assets from `web/dist`; code on Gitea `git.zacharyzhang.com` |
|
||||||
|
|
||||||
|
|||||||
@@ -0,0 +1,96 @@
|
|||||||
|
Ark Pixel Font
|
||||||
|
https://github.com/TakWolf/ark-pixel-font
|
||||||
|
|
||||||
|
Copyright (c) 2021, TakWolf (https://takwolf.com).
|
||||||
|
|
||||||
|
This Font Software is licensed under the SIL Open Font License, Version 1.1.
|
||||||
|
This license is copied below, and is also available with a FAQ at:
|
||||||
|
https://openfontlicense.org
|
||||||
|
|
||||||
|
|
||||||
|
-----------------------------------------------------------
|
||||||
|
SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
|
||||||
|
-----------------------------------------------------------
|
||||||
|
|
||||||
|
PREAMBLE
|
||||||
|
The goals of the Open Font License (OFL) are to stimulate worldwide
|
||||||
|
development of collaborative font projects, to support the font creation
|
||||||
|
efforts of academic and linguistic communities, and to provide a free and
|
||||||
|
open framework in which fonts may be shared and improved in partnership
|
||||||
|
with others.
|
||||||
|
|
||||||
|
The OFL allows the licensed fonts to be used, studied, modified and
|
||||||
|
redistributed freely as long as they are not sold by themselves. The
|
||||||
|
fonts, including any derivative works, can be bundled, embedded,
|
||||||
|
redistributed and/or sold with any software provided that any reserved
|
||||||
|
names are not used by derivative works. The fonts and derivatives,
|
||||||
|
however, cannot be released under any other type of license. The
|
||||||
|
requirement for fonts to remain under this license does not apply
|
||||||
|
to any document created using the fonts or their derivatives.
|
||||||
|
|
||||||
|
DEFINITIONS
|
||||||
|
"Font Software" refers to the set of files released by the Copyright
|
||||||
|
Holder(s) under this license and clearly marked as such. This may
|
||||||
|
include source files, build scripts and documentation.
|
||||||
|
|
||||||
|
"Reserved Font Name" refers to any names specified as such after the
|
||||||
|
copyright statement(s).
|
||||||
|
|
||||||
|
"Original Version" refers to the collection of Font Software components as
|
||||||
|
distributed by the Copyright Holder(s).
|
||||||
|
|
||||||
|
"Modified Version" refers to any derivative made by adding to, deleting,
|
||||||
|
or substituting -- in part or in whole -- any of the components of the
|
||||||
|
Original Version, by changing formats or by porting the Font Software to a
|
||||||
|
new environment.
|
||||||
|
|
||||||
|
"Author" refers to any designer, engineer, programmer, technical
|
||||||
|
writer or other person who contributed to the Font Software.
|
||||||
|
|
||||||
|
PERMISSION & CONDITIONS
|
||||||
|
Permission is hereby granted, free of charge, to any person obtaining
|
||||||
|
a copy of the Font Software, to use, study, copy, merge, embed, modify,
|
||||||
|
redistribute, and sell modified and unmodified copies of the Font
|
||||||
|
Software, subject to the following conditions:
|
||||||
|
|
||||||
|
1) Neither the Font Software nor any of its individual components,
|
||||||
|
in Original or Modified Versions, may be sold by itself.
|
||||||
|
|
||||||
|
2) Original or Modified Versions of the Font Software may be bundled,
|
||||||
|
redistributed and/or sold with any software, provided that each copy
|
||||||
|
contains the above copyright notice and this license. These can be
|
||||||
|
included either as stand-alone text files, human-readable headers or
|
||||||
|
in the appropriate machine-readable metadata fields within text or
|
||||||
|
binary files as long as those fields can be easily viewed by the user.
|
||||||
|
|
||||||
|
3) No Modified Version of the Font Software may use the Reserved Font
|
||||||
|
Name(s) unless explicit written permission is granted by the corresponding
|
||||||
|
Copyright Holder. This restriction only applies to the primary font name as
|
||||||
|
presented to the users.
|
||||||
|
|
||||||
|
4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
|
||||||
|
Software shall not be used to promote, endorse or advertise any
|
||||||
|
Modified Version, except to acknowledge the contribution(s) of the
|
||||||
|
Copyright Holder(s) and the Author(s) or with their explicit written
|
||||||
|
permission.
|
||||||
|
|
||||||
|
5) The Font Software, modified or unmodified, in part or in whole,
|
||||||
|
must be distributed entirely under this license, and must not be
|
||||||
|
distributed under any other license. The requirement for fonts to
|
||||||
|
remain under this license does not apply to any document created
|
||||||
|
using the Font Software.
|
||||||
|
|
||||||
|
TERMINATION
|
||||||
|
This license becomes null and void if any of the above conditions are
|
||||||
|
not met.
|
||||||
|
|
||||||
|
DISCLAIMER
|
||||||
|
THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
|
||||||
|
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
|
||||||
|
OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
|
||||||
|
COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
||||||
|
INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
|
||||||
|
DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||||
|
FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
|
||||||
|
OTHER DEALINGS IN THE FONT SOFTWARE.
|
||||||
+187
@@ -0,0 +1,187 @@
|
|||||||
|
package pixel
|
||||||
|
|
||||||
|
import (
|
||||||
|
_ "embed"
|
||||||
|
"encoding/binary"
|
||||||
|
"strings"
|
||||||
|
"unicode"
|
||||||
|
)
|
||||||
|
|
||||||
|
//go:embed font12.bin
|
||||||
|
var fontData []byte
|
||||||
|
|
||||||
|
// Text line height in dots at ×1.
|
||||||
|
const LineHeight = 16
|
||||||
|
|
||||||
|
type font struct {
|
||||||
|
ascent, descent, n int
|
||||||
|
index, data []byte
|
||||||
|
}
|
||||||
|
|
||||||
|
type glyph struct {
|
||||||
|
adv, w, h, x, y, stride int
|
||||||
|
rows []byte
|
||||||
|
}
|
||||||
|
|
||||||
|
var font12 = loadFont(fontData)
|
||||||
|
|
||||||
|
// tofu stands in for runes the font lacks.
|
||||||
|
var tofu = glyph{adv: 8, w: 6, h: 9, x: 1, stride: 1, rows: []byte{0xFC, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0xFC}}
|
||||||
|
|
||||||
|
func loadFont(b []byte) *font {
|
||||||
|
if len(b) < 10 || string(b[:4]) != "8BF1" {
|
||||||
|
panic("pixel: font12.bin has a bad header")
|
||||||
|
}
|
||||||
|
n := int(binary.LittleEndian.Uint32(b[6:10]))
|
||||||
|
if len(b) < 10+8*n {
|
||||||
|
panic("pixel: font12.bin index truncated")
|
||||||
|
}
|
||||||
|
return &font{ascent: int(b[4]), descent: int(b[5]), n: n, index: b[10 : 10+8*n], data: b}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (f *font) find(r rune) (glyph, bool) {
|
||||||
|
lo, hi := 0, f.n
|
||||||
|
for lo < hi {
|
||||||
|
m := int(uint(lo+hi) >> 1)
|
||||||
|
if rune(binary.LittleEndian.Uint32(f.index[8*m:])) < r {
|
||||||
|
lo = m + 1
|
||||||
|
} else {
|
||||||
|
hi = m
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if lo == f.n || rune(binary.LittleEndian.Uint32(f.index[8*lo:])) != r {
|
||||||
|
return glyph{}, false
|
||||||
|
}
|
||||||
|
off := int(binary.LittleEndian.Uint32(f.index[8*lo+4:]))
|
||||||
|
d := f.data
|
||||||
|
if off+5 > len(d) {
|
||||||
|
panic("pixel: font12.bin glyph truncated")
|
||||||
|
}
|
||||||
|
g := glyph{adv: int(d[off]), w: int(d[off+1]), h: int(d[off+2]), x: int(int8(d[off+3])), y: int(int8(d[off+4]))}
|
||||||
|
g.stride = (g.w + 7) / 8
|
||||||
|
end := off + 5 + g.h*g.stride
|
||||||
|
if end > len(d) {
|
||||||
|
panic("pixel: font12.bin glyph truncated")
|
||||||
|
}
|
||||||
|
g.rows = d[off+5 : end]
|
||||||
|
return g, true
|
||||||
|
}
|
||||||
|
|
||||||
|
func glyphOf(r rune) glyph {
|
||||||
|
if g, ok := font12.find(r); ok {
|
||||||
|
return g
|
||||||
|
}
|
||||||
|
return tofu
|
||||||
|
}
|
||||||
|
|
||||||
|
func (g glyph) on(x, y int) bool { return g.rows[y*g.stride+x/8]&(0x80>>(x%8)) != 0 }
|
||||||
|
|
||||||
|
// top is the bitmap's first row below the line top.
|
||||||
|
func (g glyph) top() int { return font12.ascent - g.y - g.h }
|
||||||
|
|
||||||
|
// Measure returns one line's width in dots at ×1.
|
||||||
|
func Measure(s string) int {
|
||||||
|
w := 0
|
||||||
|
for _, r := range s {
|
||||||
|
w += glyphOf(r).adv
|
||||||
|
}
|
||||||
|
return w
|
||||||
|
}
|
||||||
|
|
||||||
|
// Lines wraps s to width dots; zero width keeps lines.
|
||||||
|
func Lines(s string, width int) []string {
|
||||||
|
var out []string
|
||||||
|
for _, p := range strings.Split(s, "\n") {
|
||||||
|
out = append(out, wrap([]rune(p), width)...)
|
||||||
|
}
|
||||||
|
return out
|
||||||
|
}
|
||||||
|
|
||||||
|
func wrap(rs []rune, width int) []string {
|
||||||
|
if width <= 0 || Measure(string(rs)) <= width {
|
||||||
|
return []string{string(rs)}
|
||||||
|
}
|
||||||
|
var lines []string
|
||||||
|
for start := 0; start < len(rs); {
|
||||||
|
w, brk, i := 0, -1, start
|
||||||
|
for ; i < len(rs); i++ {
|
||||||
|
if i > start && breakable(rs, i) {
|
||||||
|
brk = i
|
||||||
|
}
|
||||||
|
w += glyphOf(rs[i]).adv
|
||||||
|
if w > width && i > start {
|
||||||
|
break
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if i == len(rs) {
|
||||||
|
lines = append(lines, string(rs[start:]))
|
||||||
|
break
|
||||||
|
}
|
||||||
|
if brk <= start {
|
||||||
|
brk = hardBreak(rs, start, i)
|
||||||
|
}
|
||||||
|
lines = append(lines, strings.TrimRight(string(rs[start:brk]), " "))
|
||||||
|
start = skip(rs, brk)
|
||||||
|
}
|
||||||
|
return lines
|
||||||
|
}
|
||||||
|
|
||||||
|
// breakable reports whether a line may break before rs[i].
|
||||||
|
func breakable(rs []rune, i int) bool {
|
||||||
|
if n := skip(rs, i); n < len(rs) && closer(rs[n]) || opener(rs[back(rs, 0, i)]) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
return rs[i] == ' ' || rs[i-1] == ' ' || wide(rs[i]) || wide(rs[i-1])
|
||||||
|
}
|
||||||
|
|
||||||
|
// hardBreak splits an overlong run, keeping punctuation attached.
|
||||||
|
func hardBreak(rs []rune, start, i int) int {
|
||||||
|
q, hangs := i, false
|
||||||
|
for q > start && (rs[q-1] == ' ' || opener(rs[q-1])) {
|
||||||
|
hangs = hangs || opener(rs[q-1])
|
||||||
|
q--
|
||||||
|
}
|
||||||
|
switch {
|
||||||
|
case hangs && q > start:
|
||||||
|
return q
|
||||||
|
case hangs:
|
||||||
|
for i < len(rs) && (rs[i] == ' ' || opener(rs[i])) {
|
||||||
|
i++
|
||||||
|
}
|
||||||
|
i = min(i+1, len(rs))
|
||||||
|
}
|
||||||
|
for n := skip(rs, i); n < len(rs) && closer(rs[n]); n = skip(rs, i) {
|
||||||
|
i = n + 1
|
||||||
|
}
|
||||||
|
return i
|
||||||
|
}
|
||||||
|
|
||||||
|
func skip(rs []rune, i int) int {
|
||||||
|
for i < len(rs) && rs[i] == ' ' {
|
||||||
|
i++
|
||||||
|
}
|
||||||
|
return i
|
||||||
|
}
|
||||||
|
|
||||||
|
// back returns the last non-space index before i.
|
||||||
|
func back(rs []rune, start, i int) int {
|
||||||
|
p := i - 1
|
||||||
|
for p > start && rs[p] == ' ' {
|
||||||
|
p--
|
||||||
|
}
|
||||||
|
return p
|
||||||
|
}
|
||||||
|
|
||||||
|
func closer(r rune) bool {
|
||||||
|
return unicode.In(r, unicode.Pe, unicode.Pf) || strings.ContainsRune(stops, r)
|
||||||
|
}
|
||||||
|
|
||||||
|
func opener(r rune) bool { return unicode.In(r, unicode.Ps, unicode.Pi) }
|
||||||
|
|
||||||
|
// Sentence ends that must not start a line.
|
||||||
|
const stops = ",.;:!?,。、;:?!…‥·・"
|
||||||
|
|
||||||
|
func wide(r rune) bool {
|
||||||
|
return unicode.In(r, unicode.Han, unicode.Hiragana, unicode.Katakana, unicode.Hangul) ||
|
||||||
|
r >= 0x3000 && r <= 0x303F || r >= 0xFF00 && r <= 0xFFEF
|
||||||
|
}
|
||||||
Binary file not shown.
@@ -0,0 +1,218 @@
|
|||||||
|
package pixel
|
||||||
|
|
||||||
|
import (
|
||||||
|
"encoding/binary"
|
||||||
|
"encoding/hex"
|
||||||
|
"math/rand/v2"
|
||||||
|
"slices"
|
||||||
|
"strings"
|
||||||
|
"testing"
|
||||||
|
)
|
||||||
|
|
||||||
|
func TestFontHeader(t *testing.T) {
|
||||||
|
if font12.n != 24870 || font12.ascent != 13 || font12.descent != 3 {
|
||||||
|
t.Fatalf("font: %d glyphs, ascent %d, descent %d", font12.n, font12.ascent, font12.descent)
|
||||||
|
}
|
||||||
|
if LineHeight != font12.ascent+font12.descent {
|
||||||
|
t.Fatalf("LineHeight %d, want %d", LineHeight, font12.ascent+font12.descent)
|
||||||
|
}
|
||||||
|
prev := rune(-1)
|
||||||
|
for i := range font12.n {
|
||||||
|
r := rune(binary.LittleEndian.Uint32(font12.index[8*i:]))
|
||||||
|
if r <= prev {
|
||||||
|
t.Fatalf("index entry %d: %U after %U", i, r, prev)
|
||||||
|
}
|
||||||
|
prev = r
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestBadFontPanics(t *testing.T) {
|
||||||
|
for name, b := range map[string][]byte{
|
||||||
|
"magic": []byte("XXXX\x0d\x03\x00\x00\x00\x00"),
|
||||||
|
"truncated": []byte("8BF1\x0d\x03\x05\x00\x00\x00"),
|
||||||
|
} {
|
||||||
|
func() {
|
||||||
|
defer func() {
|
||||||
|
if recover() == nil {
|
||||||
|
t.Errorf("%s: loadFont did not panic", name)
|
||||||
|
}
|
||||||
|
}()
|
||||||
|
loadFont(b)
|
||||||
|
}()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Rows copied from ark-pixel-12px-proportional-zh_hans.bdf v2026.09.25.
|
||||||
|
func TestGlyphsMatchBDF(t *testing.T) {
|
||||||
|
cases := []struct {
|
||||||
|
r rune
|
||||||
|
adv, w, h, x, y, top int
|
||||||
|
hexRows string
|
||||||
|
}{
|
||||||
|
{'A', 8, 7, 9, 0, 0, 4, "10 10 28 28 44 7C 44 82 82"},
|
||||||
|
{'g', 6, 5, 8, 0, -2, 7, "78 88 88 88 88 78 08 70"},
|
||||||
|
{'中', 12, 11, 11, 0, -1, 3, "0400 0400 FFE0 8420 8420 8420 FFE0 0400 0400 0400 0400"},
|
||||||
|
{',', 12, 2, 4, 2, -1, 10, "C0 C0 40 80"},
|
||||||
|
{' ', 6, 0, 0, 0, 0, 13, ""},
|
||||||
|
}
|
||||||
|
for _, c := range cases {
|
||||||
|
g, ok := font12.find(c.r)
|
||||||
|
if !ok {
|
||||||
|
t.Fatalf("%q missing", c.r)
|
||||||
|
}
|
||||||
|
if g.adv != c.adv || g.w != c.w || g.h != c.h || g.x != c.x || g.y != c.y {
|
||||||
|
t.Fatalf("%q metrics adv %d box %d×%d at %d,%d", c.r, g.adv, g.w, g.h, g.x, g.y)
|
||||||
|
}
|
||||||
|
var want []byte
|
||||||
|
for _, row := range strings.Fields(c.hexRows) {
|
||||||
|
b, _ := hex.DecodeString(row)
|
||||||
|
want = append(want, b...)
|
||||||
|
}
|
||||||
|
if !slices.Equal(g.rows, want) {
|
||||||
|
t.Fatalf("%q rows % X, want % X", c.r, g.rows, want)
|
||||||
|
}
|
||||||
|
if got := g.top(); got != c.top {
|
||||||
|
t.Fatalf("%q top %d, want %d", c.r, got, c.top)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
a := glyphOf('A')
|
||||||
|
if !a.on(3, 0) || a.on(0, 0) || !a.on(0, 8) || !a.on(6, 8) {
|
||||||
|
t.Fatal("'A' bits read wrong")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestMissingRuneDrawsTofu(t *testing.T) {
|
||||||
|
const r = '\U0001F600'
|
||||||
|
if _, ok := font12.find(r); ok {
|
||||||
|
t.Fatalf("%U is in the font; pick a missing rune", r)
|
||||||
|
}
|
||||||
|
if g := glyphOf(r); g.adv != tofu.adv || !slices.Equal(g.rows, tofu.rows) {
|
||||||
|
t.Fatalf("%U = adv %d, want tofu", r, g.adv)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestMeasure(t *testing.T) {
|
||||||
|
if got := Measure("Ag中"); got != 8+6+12 {
|
||||||
|
t.Fatalf("Measure = %d, want 26", got)
|
||||||
|
}
|
||||||
|
if Measure("") != 0 {
|
||||||
|
t.Fatal("Measure of empty text is not 0")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestLines(t *testing.T) {
|
||||||
|
cases := []struct {
|
||||||
|
s string
|
||||||
|
width int
|
||||||
|
want []string
|
||||||
|
}{
|
||||||
|
{"HELLO WORLD", max(Measure("HELLO"), Measure("WORLD")) + 2, []string{"HELLO", "WORLD"}},
|
||||||
|
{"像素风格组件库", 36, []string{"像素风", "格组件", "库"}},
|
||||||
|
{"你好,世界", 24, []string{"你", "好,", "世界"}},
|
||||||
|
{"「像素」", 24, []string{"「像", "素」"}},
|
||||||
|
{"A\nB", 100, []string{"A", "B"}},
|
||||||
|
{"a long line", 0, []string{"a long line"}},
|
||||||
|
{"x y", Measure("x"), []string{"x", "y"}},
|
||||||
|
{"你 ,好", 24, []string{"你 ,", "好"}},
|
||||||
|
{"「 像素", 18, []string{"「 像", "素"}},
|
||||||
|
{"[你好]世界", 36, []string{"[你", "好]世", "界"}},
|
||||||
|
{"「 像素", 18, []string{"「 像", "素"}},
|
||||||
|
{"「(像素)」", 18, []string{"「(像", "素)」"}},
|
||||||
|
{"「(像素)」", 24, []string{"「(像", "素)」"}},
|
||||||
|
{"AB「(C", Measure("AB") + 4, []string{"AB", "「(C"}},
|
||||||
|
}
|
||||||
|
for _, c := range cases {
|
||||||
|
if got := Lines(c.s, c.width); !slices.Equal(got, c.want) {
|
||||||
|
t.Errorf("Lines(%q, %d) = %q, want %q", c.s, c.width, got, c.want)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestLinesFitAndKeepText(t *testing.T) {
|
||||||
|
texts := []string{
|
||||||
|
"The quick brown fox jumps over the lazy dog near the riverbank.",
|
||||||
|
"像素风格的组件库,在限制中创造丰富。每个点都经过认真摆放!",
|
||||||
|
"Mixed 中英文 text with ABCDEFGHIJKLMNOPQRSTUVWXYZ and 標點,結束。",
|
||||||
|
"Supercalifragilisticexpialidocious",
|
||||||
|
"「像素」风格 (测试) 文本 ,结束 。再见",
|
||||||
|
"[测试]{内容}〔括号〕《书名》“引号”‘单引’",
|
||||||
|
"「(像素)」 「 空格」 『《嵌套》』",
|
||||||
|
}
|
||||||
|
for _, s := range texts {
|
||||||
|
for width := 6; width <= 120; width += 7 {
|
||||||
|
lines := Lines(s, width)
|
||||||
|
for _, l := range lines {
|
||||||
|
core := strings.TrimLeftFunc(strings.TrimRightFunc(l, hanging(closer)), hanging(opener))
|
||||||
|
if Measure(core) > width && len([]rune(core)) > 1 {
|
||||||
|
t.Fatalf("Lines(%q, %d): %q is %d wide", s, width, l, Measure(l))
|
||||||
|
}
|
||||||
|
if r := []rune(l); closer(r[0]) {
|
||||||
|
t.Fatalf("Lines(%q, %d): %q starts with a closer", s, width, l)
|
||||||
|
}
|
||||||
|
if r := []rune(l); opener(r[len(r)-1]) {
|
||||||
|
t.Fatalf("Lines(%q, %d): %q ends with an opener", s, width, l)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if got := strings.ReplaceAll(strings.Join(lines, ""), " ", ""); got != strings.ReplaceAll(s, " ", "") {
|
||||||
|
t.Fatalf("Lines(%q, %d) lost text: %q", s, width, got)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestLinesRandom(t *testing.T) {
|
||||||
|
alphabet := []rune("ab 像素,。「」()[]《》“”!?.WM")
|
||||||
|
rng := rand.New(rand.NewPCG(8, 16))
|
||||||
|
for n := range 3000 {
|
||||||
|
rs := make([]rune, 1+rng.IntN(24))
|
||||||
|
for i := range rs {
|
||||||
|
rs[i] = alphabet[rng.IntN(len(alphabet))]
|
||||||
|
}
|
||||||
|
s, width := string(rs), 6+rng.IntN(60)
|
||||||
|
lines := Lines(s, width)
|
||||||
|
for j, l := range lines {
|
||||||
|
r := []rune(strings.TrimRight(l, " "))
|
||||||
|
if len(r) == 0 {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
core := strings.TrimLeftFunc(strings.TrimRightFunc(l, hanging(closer)), hanging(opener))
|
||||||
|
if j > 0 && closer(r[0]) || j < len(lines)-1 && opener(r[len(r)-1]) || Measure(core) > width && len([]rune(core)) > 1 {
|
||||||
|
t.Fatalf("case %d: Lines(%q, %d) = %q", n, s, width, lines)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if got := strings.ReplaceAll(strings.Join(lines, ""), " ", ""); got != strings.ReplaceAll(s, " ", "") {
|
||||||
|
t.Fatalf("case %d: Lines(%q, %d) lost text: %q", n, s, width, lines)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func hanging(punct func(rune) bool) func(rune) bool {
|
||||||
|
return func(r rune) bool { return r == ' ' || punct(r) }
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestMicroFont(t *testing.T) {
|
||||||
|
set := "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ+-.:/%! "
|
||||||
|
seen := map[[MicroHeight]uint8]rune{}
|
||||||
|
for _, r := range set {
|
||||||
|
g := microGlyph(r)
|
||||||
|
if prev, ok := seen[g]; ok && r != ' ' {
|
||||||
|
t.Errorf("micro %q and %q are the same glyph", prev, r)
|
||||||
|
}
|
||||||
|
seen[g] = r
|
||||||
|
}
|
||||||
|
if microGlyph('a') != microGlyph('A') {
|
||||||
|
t.Fatal("micro font does not upper-case")
|
||||||
|
}
|
||||||
|
if got := microGlyph('1'); got != [MicroHeight]uint8{2, 6, 2, 2, 7} {
|
||||||
|
t.Fatalf("micro '1' = %v", got)
|
||||||
|
}
|
||||||
|
if MicroWidth("HP 99") != 19 || MicroWidth("") != 0 {
|
||||||
|
t.Fatalf("MicroWidth = %d, %d", MicroWidth("HP 99"), MicroWidth(""))
|
||||||
|
}
|
||||||
|
defer func() {
|
||||||
|
if recover() == nil {
|
||||||
|
t.Fatal("micro '#' did not panic")
|
||||||
|
}
|
||||||
|
}()
|
||||||
|
MicroWidth("#")
|
||||||
|
}
|
||||||
+104
@@ -0,0 +1,104 @@
|
|||||||
|
package pixel
|
||||||
|
|
||||||
|
import (
|
||||||
|
"fmt"
|
||||||
|
"strings"
|
||||||
|
"unicode"
|
||||||
|
)
|
||||||
|
|
||||||
|
const (
|
||||||
|
MicroAdvance = 4
|
||||||
|
MicroHeight = 5
|
||||||
|
)
|
||||||
|
|
||||||
|
// Hand-placed 3×5 glyphs; rows split by |.
|
||||||
|
var micro = microFont(map[rune]string{
|
||||||
|
' ': "...|...|...|...|...",
|
||||||
|
'0': "###|#.#|#.#|#.#|###",
|
||||||
|
'1': ".#.|##.|.#.|.#.|###",
|
||||||
|
'2': "###|..#|###|#..|###",
|
||||||
|
'3': "###|..#|.##|..#|###",
|
||||||
|
'4': "#.#|#.#|###|..#|..#",
|
||||||
|
'5': "###|#..|###|..#|###",
|
||||||
|
'6': "###|#..|###|#.#|###",
|
||||||
|
'7': "###|..#|.#.|.#.|.#.",
|
||||||
|
'8': "###|#.#|###|#.#|###",
|
||||||
|
'9': "###|#.#|###|..#|###",
|
||||||
|
'A': ".#.|#.#|###|#.#|#.#",
|
||||||
|
'B': "##.|#.#|##.|#.#|##.",
|
||||||
|
'C': ".##|#..|#..|#..|.##",
|
||||||
|
'D': "##.|#.#|#.#|#.#|##.",
|
||||||
|
'E': "###|#..|##.|#..|###",
|
||||||
|
'F': "###|#..|##.|#..|#..",
|
||||||
|
'G': ".##|#..|#.#|#.#|.##",
|
||||||
|
'H': "#.#|#.#|###|#.#|#.#",
|
||||||
|
'I': "###|.#.|.#.|.#.|###",
|
||||||
|
'J': "..#|..#|..#|#.#|.#.",
|
||||||
|
'K': "#.#|#.#|##.|#.#|#.#",
|
||||||
|
'L': "#..|#..|#..|#..|###",
|
||||||
|
'M': "#.#|###|###|#.#|#.#",
|
||||||
|
'N': "##.|#.#|#.#|#.#|#.#",
|
||||||
|
'O': ".#.|#.#|#.#|#.#|.#.",
|
||||||
|
'P': "##.|#.#|##.|#..|#..",
|
||||||
|
'Q': ".#.|#.#|#.#|##.|.##",
|
||||||
|
'R': "##.|#.#|##.|#.#|#.#",
|
||||||
|
'S': ".##|#..|.#.|..#|##.",
|
||||||
|
'T': "###|.#.|.#.|.#.|.#.",
|
||||||
|
'U': "#.#|#.#|#.#|#.#|###",
|
||||||
|
'V': "#.#|#.#|#.#|#.#|.#.",
|
||||||
|
'W': "#.#|#.#|###|###|#.#",
|
||||||
|
'X': "#.#|#.#|.#.|#.#|#.#",
|
||||||
|
'Y': "#.#|#.#|.#.|.#.|.#.",
|
||||||
|
'Z': "###|..#|.#.|#..|###",
|
||||||
|
'+': "...|.#.|###|.#.|...",
|
||||||
|
'-': "...|...|###|...|...",
|
||||||
|
'.': "...|...|...|...|.#.",
|
||||||
|
':': "...|.#.|...|.#.|...",
|
||||||
|
'/': "..#|..#|.#.|#..|#..",
|
||||||
|
'%': "#.#|..#|.#.|#..|#.#",
|
||||||
|
'!': ".#.|.#.|.#.|...|.#.",
|
||||||
|
})
|
||||||
|
|
||||||
|
func microFont(art map[rune]string) map[rune][MicroHeight]uint8 {
|
||||||
|
out := map[rune][MicroHeight]uint8{}
|
||||||
|
for r, a := range art {
|
||||||
|
rows := strings.Split(a, "|")
|
||||||
|
if len(rows) != MicroHeight {
|
||||||
|
panic(fmt.Sprintf("pixel: micro %q needs %d rows", r, MicroHeight))
|
||||||
|
}
|
||||||
|
var g [MicroHeight]uint8
|
||||||
|
for y, row := range rows {
|
||||||
|
if len(row) != 3 || strings.Trim(row, ".#") != "" {
|
||||||
|
panic(fmt.Sprintf("pixel: micro %q row %q", r, row))
|
||||||
|
}
|
||||||
|
for x := range 3 {
|
||||||
|
if row[x] == '#' {
|
||||||
|
g[y] |= 4 >> x
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
out[r] = g
|
||||||
|
}
|
||||||
|
return out
|
||||||
|
}
|
||||||
|
|
||||||
|
func microGlyph(r rune) [MicroHeight]uint8 {
|
||||||
|
g, ok := micro[unicode.ToUpper(r)]
|
||||||
|
if !ok {
|
||||||
|
panic(fmt.Sprintf("pixel: micro font lacks %q", r))
|
||||||
|
}
|
||||||
|
return g
|
||||||
|
}
|
||||||
|
|
||||||
|
// MicroWidth returns the width of s in dots.
|
||||||
|
func MicroWidth(s string) int {
|
||||||
|
n := 0
|
||||||
|
for _, r := range s {
|
||||||
|
microGlyph(r)
|
||||||
|
n++
|
||||||
|
}
|
||||||
|
if n == 0 {
|
||||||
|
return 0
|
||||||
|
}
|
||||||
|
return n*MicroAdvance - 1
|
||||||
|
}
|
||||||
@@ -0,0 +1,154 @@
|
|||||||
|
// Command fontpack packs a BDF bitmap font for package pixel.
|
||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"bufio"
|
||||||
|
"cmp"
|
||||||
|
"encoding/binary"
|
||||||
|
"encoding/hex"
|
||||||
|
"errors"
|
||||||
|
"flag"
|
||||||
|
"fmt"
|
||||||
|
"io"
|
||||||
|
"log"
|
||||||
|
"os"
|
||||||
|
"slices"
|
||||||
|
"strconv"
|
||||||
|
"strings"
|
||||||
|
)
|
||||||
|
|
||||||
|
type glyph struct {
|
||||||
|
r rune
|
||||||
|
adv int
|
||||||
|
w, h, x, y int
|
||||||
|
rows []byte
|
||||||
|
}
|
||||||
|
|
||||||
|
func main() {
|
||||||
|
in := flag.String("in", "", "BDF file")
|
||||||
|
out := flag.String("out", "pixel/font12.bin", "packed font")
|
||||||
|
flag.Parse()
|
||||||
|
f, err := os.Open(*in)
|
||||||
|
if err != nil {
|
||||||
|
log.Fatal(err)
|
||||||
|
}
|
||||||
|
defer f.Close()
|
||||||
|
asc, desc, gs, err := parse(f)
|
||||||
|
if err != nil {
|
||||||
|
log.Fatalf("fontpack: %s: %v", *in, err)
|
||||||
|
}
|
||||||
|
data, err := pack(asc, desc, gs)
|
||||||
|
if err != nil {
|
||||||
|
log.Fatalf("fontpack: %v", err)
|
||||||
|
}
|
||||||
|
if err := os.WriteFile(*out, data, 0o644); err != nil {
|
||||||
|
log.Fatal(err)
|
||||||
|
}
|
||||||
|
log.Printf("fontpack: %d glyphs, %d bytes, %s", len(gs), len(data), *out)
|
||||||
|
}
|
||||||
|
|
||||||
|
func parse(r io.Reader) (asc, desc int, gs []glyph, err error) {
|
||||||
|
asc, desc = -1, -1
|
||||||
|
sc := bufio.NewScanner(r)
|
||||||
|
var g *glyph
|
||||||
|
inBitmap := false
|
||||||
|
line := 0
|
||||||
|
for sc.Scan() {
|
||||||
|
line++
|
||||||
|
f := strings.Fields(sc.Text())
|
||||||
|
if len(f) == 0 {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
bad := func(e error) (int, int, []glyph, error) { return 0, 0, nil, fmt.Errorf("line %d: %w", line, e) }
|
||||||
|
switch {
|
||||||
|
case inBitmap && f[0] == "ENDCHAR":
|
||||||
|
if len(g.rows) != g.h*((g.w+7)/8) {
|
||||||
|
return bad(fmt.Errorf("glyph %U has %d bitmap bytes, want %d", g.r, len(g.rows), g.h*((g.w+7)/8)))
|
||||||
|
}
|
||||||
|
if g.r >= 0 {
|
||||||
|
gs = append(gs, *g)
|
||||||
|
}
|
||||||
|
g, inBitmap = nil, false
|
||||||
|
case inBitmap:
|
||||||
|
b, err := hex.DecodeString(f[0])
|
||||||
|
if err != nil || len(b) != (g.w+7)/8 {
|
||||||
|
return bad(fmt.Errorf("glyph %U row %q", g.r, f[0]))
|
||||||
|
}
|
||||||
|
g.rows = append(g.rows, b...)
|
||||||
|
case f[0] == "FONT_ASCENT":
|
||||||
|
asc, err = number(f)
|
||||||
|
case f[0] == "FONT_DESCENT":
|
||||||
|
desc, err = number(f)
|
||||||
|
case f[0] == "STARTCHAR":
|
||||||
|
g = &glyph{r: -1}
|
||||||
|
case g == nil:
|
||||||
|
case f[0] == "ENCODING":
|
||||||
|
var e int
|
||||||
|
e, err = number(f)
|
||||||
|
g.r = rune(e)
|
||||||
|
case f[0] == "DWIDTH":
|
||||||
|
g.adv, err = number(f)
|
||||||
|
case f[0] == "BBX":
|
||||||
|
if len(f) != 5 {
|
||||||
|
return bad(errors.New("BBX needs four numbers"))
|
||||||
|
}
|
||||||
|
v := make([]int, 4)
|
||||||
|
for i := range v {
|
||||||
|
if v[i], err = strconv.Atoi(f[i+1]); err != nil {
|
||||||
|
return bad(err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
g.w, g.h, g.x, g.y = v[0], v[1], v[2], v[3]
|
||||||
|
if g.w < 0 || g.h < 0 {
|
||||||
|
return bad(fmt.Errorf("glyph %U has a negative box", g.r))
|
||||||
|
}
|
||||||
|
case f[0] == "BITMAP":
|
||||||
|
inBitmap = true
|
||||||
|
}
|
||||||
|
if err != nil {
|
||||||
|
return bad(err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if err := sc.Err(); err != nil {
|
||||||
|
return 0, 0, nil, err
|
||||||
|
}
|
||||||
|
if g != nil {
|
||||||
|
return 0, 0, nil, fmt.Errorf("glyph %U has no ENDCHAR", g.r)
|
||||||
|
}
|
||||||
|
if asc < 0 || desc < 0 {
|
||||||
|
return 0, 0, nil, errors.New("FONT_ASCENT or FONT_DESCENT missing")
|
||||||
|
}
|
||||||
|
return asc, desc, gs, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func number(f []string) (int, error) {
|
||||||
|
if len(f) < 2 {
|
||||||
|
return 0, fmt.Errorf("%s needs a number", f[0])
|
||||||
|
}
|
||||||
|
return strconv.Atoi(f[1])
|
||||||
|
}
|
||||||
|
|
||||||
|
// Layout: magic, ascent, descent, count, index, glyphs.
|
||||||
|
func pack(asc, desc int, gs []glyph) ([]byte, error) {
|
||||||
|
slices.SortFunc(gs, func(a, b glyph) int { return cmp.Compare(a.r, b.r) })
|
||||||
|
if asc > 255 || desc > 255 {
|
||||||
|
return nil, fmt.Errorf("ascent %d or descent %d over 255", asc, desc)
|
||||||
|
}
|
||||||
|
out := []byte{'8', 'B', 'F', '1', byte(asc), byte(desc)}
|
||||||
|
out = binary.LittleEndian.AppendUint32(out, uint32(len(gs)))
|
||||||
|
index := len(out)
|
||||||
|
out = append(out, make([]byte, 8*len(gs))...)
|
||||||
|
for i, g := range gs {
|
||||||
|
if i > 0 && gs[i-1].r == g.r {
|
||||||
|
return nil, fmt.Errorf("glyph %U twice", g.r)
|
||||||
|
}
|
||||||
|
if g.adv < 0 || g.adv > 255 || g.w < 0 || g.w > 255 || g.h < 0 || g.h > 255 || g.x < -128 || g.x > 127 || g.y < -128 || g.y > 127 {
|
||||||
|
return nil, fmt.Errorf("glyph %U metrics out of range", g.r)
|
||||||
|
}
|
||||||
|
binary.LittleEndian.PutUint32(out[index+8*i:], uint32(g.r))
|
||||||
|
binary.LittleEndian.PutUint32(out[index+8*i+4:], uint32(len(out)))
|
||||||
|
out = append(out, byte(g.adv), byte(g.w), byte(g.h), byte(int8(g.x)), byte(int8(g.y)))
|
||||||
|
out = append(out, g.rows...)
|
||||||
|
}
|
||||||
|
return out, nil
|
||||||
|
}
|
||||||
@@ -0,0 +1,102 @@
|
|||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"encoding/binary"
|
||||||
|
"strings"
|
||||||
|
"testing"
|
||||||
|
)
|
||||||
|
|
||||||
|
const sample = `STARTFONT 2.1
|
||||||
|
FONT_ASCENT 13
|
||||||
|
FONT_DESCENT 3
|
||||||
|
CHARS 4
|
||||||
|
STARTCHAR B
|
||||||
|
ENCODING 66
|
||||||
|
DWIDTH 7 0
|
||||||
|
BBX 5 2 1 0
|
||||||
|
BITMAP
|
||||||
|
F8
|
||||||
|
88
|
||||||
|
ENDCHAR
|
||||||
|
STARTCHAR unencoded
|
||||||
|
ENCODING -1
|
||||||
|
DWIDTH 3 0
|
||||||
|
BBX 1 1 0 0
|
||||||
|
BITMAP
|
||||||
|
80
|
||||||
|
ENDCHAR
|
||||||
|
STARTCHAR A
|
||||||
|
ENCODING 65
|
||||||
|
DWIDTH 8 0
|
||||||
|
BBX 9 1 0 -2
|
||||||
|
BITMAP
|
||||||
|
FF80
|
||||||
|
ENDCHAR
|
||||||
|
STARTCHAR space
|
||||||
|
ENCODING 32
|
||||||
|
DWIDTH 6 0
|
||||||
|
BBX 0 0 0 0
|
||||||
|
BITMAP
|
||||||
|
ENDCHAR
|
||||||
|
ENDFONT
|
||||||
|
`
|
||||||
|
|
||||||
|
func TestParseAndPack(t *testing.T) {
|
||||||
|
asc, desc, gs, err := parse(strings.NewReader(sample))
|
||||||
|
if err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
if asc != 13 || desc != 3 || len(gs) != 3 {
|
||||||
|
t.Fatalf("ascent %d descent %d glyphs %d", asc, desc, len(gs))
|
||||||
|
}
|
||||||
|
b, err := pack(asc, desc, gs)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
if string(b[:4]) != "8BF1" || b[4] != 13 || b[5] != 3 || binary.LittleEndian.Uint32(b[6:]) != 3 {
|
||||||
|
t.Fatalf("header % X", b[:10])
|
||||||
|
}
|
||||||
|
runes := []rune{' ', 'A', 'B'}
|
||||||
|
records := [][]byte{
|
||||||
|
{6, 0, 0, 0, 0},
|
||||||
|
{8, 9, 1, 0, 0xFE, 0xFF, 0x80},
|
||||||
|
{7, 5, 2, 1, 0, 0xF8, 0x88},
|
||||||
|
}
|
||||||
|
for i, r := range runes {
|
||||||
|
e := b[10+8*i:]
|
||||||
|
if got := rune(binary.LittleEndian.Uint32(e)); got != r {
|
||||||
|
t.Fatalf("index %d rune %U, want %U", i, got, r)
|
||||||
|
}
|
||||||
|
off := int(binary.LittleEndian.Uint32(e[4:]))
|
||||||
|
if got := b[off : off+len(records[i])]; string(got) != string(records[i]) {
|
||||||
|
t.Fatalf("%U record % X, want % X", r, got, records[i])
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestParseErrors(t *testing.T) {
|
||||||
|
cases := map[string]string{
|
||||||
|
"no ascent": strings.Replace(sample, "FONT_ASCENT 13\n", "", 1),
|
||||||
|
"short rows": strings.Replace(sample, "F8\n88\n", "F8\n", 1),
|
||||||
|
"bad hex": strings.Replace(sample, "F8\n", "ZZ\n", 1),
|
||||||
|
"wide row": strings.Replace(sample, "F8\n", "F800\n", 1),
|
||||||
|
"bad bbx": strings.Replace(sample, "BBX 5 2 1 0", "BBX 5 2", 1),
|
||||||
|
"no ENDCHAR": strings.TrimSuffix(sample, "ENDCHAR\nENDFONT\n"),
|
||||||
|
"negative": strings.Replace(sample, "BBX 0 0 0 0", "BBX -1 -1 0 0", 1),
|
||||||
|
}
|
||||||
|
for name, src := range cases {
|
||||||
|
if _, _, _, err := parse(strings.NewReader(src)); err == nil {
|
||||||
|
t.Errorf("%s: no error", name)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestPackRejectsDuplicates(t *testing.T) {
|
||||||
|
gs := []glyph{{r: 'A', adv: 1}, {r: 'A', adv: 2}}
|
||||||
|
if _, err := pack(13, 3, gs); err == nil {
|
||||||
|
t.Fatal("duplicate rune packed")
|
||||||
|
}
|
||||||
|
if _, err := pack(13, 3, []glyph{{r: 'A', adv: 300}}); err == nil {
|
||||||
|
t.Fatal("advance 300 packed")
|
||||||
|
}
|
||||||
|
}
|
||||||
Reference in new issue
Block a user