FNT — Font bitmap a 1 bit

Total Annihilation include tutta una serie di file .fnt per qualsiasi cosa, dalle comunicazioni radio a schermo (comix.fnt) alle schermate di briefing delle unità (armbrief.fnt). Sono piccoli font bitmap a larghezza variabile, a 1 bit per pixel, indicizzati per codice di carattere a 8 bit: in sostanza un foglio di sprite con una tabella di ricerca.

fonts/comix.fnt disegnato come foglio di sprite a 16 colonne da kbot fnt sheet

kbot fnt render comix.fnt --text "kbot" --fg "#ffff00" --bg "#000000"

kbot fnt info     fonts/comix.fnt                    # one-line summary
kbot fnt describe fonts/comix.fnt --list             # full metadata + glyph list
kbot fnt sheet    fonts/comix.fnt -o sheet.png       # all glyphs as a grid
kbot fnt render   fonts/comix.fnt --text "Commander" --fg "#ffff00" --bg transparent -o caption.png
kbot fnt dump     fonts/comix.fnt -t ./glyphs        # one PNG per character

import "github.com/coreprime/kbot/formats/fnt"

f, _ := os.Open("fonts/comix.fnt")
defer f.Close()
font, _ := fnt.LoadFromReader(f)
fmt.Println(font.Height, "px,", font.GlyphCount(), "glyphs")
if g := font.Glyphs['A']; g != nil {
    fmt.Println("A is", g.Width, "px wide")
}

Struttura su disco#

┌─ 4-byte header ──────────┐
│ uint8   Height           │   byte 0: shared by every glyph; the line height
│ uint8   (ignored)        │   byte 1: not part of the height
│ int8    Baseline         │   byte 2: rows the glyphs extend above the pen
│ uint8   FirstChar        │   byte 3: code of the first offset-table entry
├─ (256 − FirstChar) × u16 ┤   file offsets; 0 = glyph not defined
├─ Glyph data ─────────────┤   for each defined glyph:
│   uint8  Width           │   pixel width (1..255), also the pen advance
│   ⌈Width × Height/8⌉     │   1bpp pixels, MSB-first bit stream
└──────────────────────────┘

Ogni font originale ha FirstChar = 0, quindi la sua intestazione più la tabella degli offset occupano 4 + 256 × 2 = 516 byte e i dati dei glifi cominciano subito dopo.

Gli strumenti più vecchi leggono i byte 2–3 come un'unica parola opaca di "flag"; sono invece due campi separati.

Leggere un glifo#

Il payload del glifo è un flusso di bit continuo, MSB-first, impacchettato da sinistra a destra e poi dall'alto in basso, cioè una scansione per righe. Il numero di bit è Width × Height e il numero di byte memorizzati è ⌈(Width × Height) / 8⌉.

def read_glyph(file, offset, height):
    file.seek(offset)
    width = file.read(1)[0]
    if width == 0 or width > 128:
        return None
    n_bits  = width * height
    n_bytes = (n_bits + 7) // 8
    bits    = file.read(n_bytes)
    pixels  = []
    for i in range(n_bits):
        bit = (bits[i // 8] >> (7 - (i % 8))) & 1
        pixels.append(bool(bit))
    return Glyph(width, height, pixels)

Non ci sono dati di crenatura (kerning) né una larghezza di avanzamento distinta da Width. Il gioco dispone il testo così, e kbot fnt render, lo strumento MCP fnt_render e l'anteprima del testo dell'esploratore di asset fanno lo stesso:

• ogni byte del testo seleziona il glifo con quel codice (converti prima il testo UTF-8 nella codepage del gioco; kbot fnt render --codepage usa Windows-1252 come predefinita);
• un glifo fa avanzare la penna di esattamente la sua larghezza, senza spazio in mezzo;
• un carattere senza glifo non disegna nulla e avanza di 0;
• il disegno si ferma al primo NUL o a capo.

Un font di 13 righe con una A larga 10 pixel e senza glifo per lo spazio disegna quindi "A A" largo 20 pixel.

Esempio svolto — comix.fnt#

$ kbot fnt describe fonts/comix.fnt
Height:        14 px
Baseline:      1 (glyph rows start this many rows above the pen)
First char:    0x00
Glyphs:        94 / 256 defined
Glyph width:   min=3 max=13 mean=5.9
Ranges:        0x20-0x7D

Come leggerlo: è un font alto 14 pixel che copre l'ASCII stampabile (dallo spazio a }). Le larghezze vanno da 3 (i, l) a 13 (M, W). I 162 slot non definiti sono per lo più caratteri di controllo non stampabili; il resto sono caratteri aggiuntivi Latin-1 che il gioco non mostra.

La tabella degli offset per i primi dieci caratteri di comix.fnt:

char  offset    width  bytes  meaning
0x20  0x021C    4      7     space
0x21  0x0223    3      5     '!'
0x22  0x0228    5      9     '"'
0x23  0x0231    6     11     '#'
0x24  0x023C    5      9     '$'
...

Puoi ottenere lo stesso elenco con kbot fnt describe --list.

Consigli per il rendering#

kbot fnt render supporta:

Un carattere che non è presente nel font non disegna nulla e non occupa spazio, come nel gioco.

Insidie#

• L'ordine dei bit è MSB-first all'interno di ciascun byte. Nei font bitmap moderni la convenzione più comune è LSB-first; non darlo per scontato.
• Il flusso di bit è continuo tra una riga e l'altra: non c'è riempimento fino al confine di byte alla fine di ogni riga di scansione.
• I byte 2 e 3 sono la linea di base e il codice del primo carattere, non una parola di flag. Un codice del primo carattere diverso da zero accorcia la tabella degli offset.
• I caratteri sono byte, non code point Unicode. € è il byte 0x80 in Windows-1252; prendere un code point modulo 256 sceglie il glifo sbagliato.
• Nessun metadato su quali caratteri siano supportati. Per scoprire l'insieme dei glifi devi scorrere la tabella degli offset.

Dimensioni tipiche#

Vedi anche#

• PAL: i font non contengono una palette; per il rendering devi scegliere un colore di primo piano e di sfondo, oppure usare a mano la palette di TA.
• Glossario: 1bpp, flusso di bit MSB-first.