Files
RetroArch/tools/bitmapfont_convert.py
B 21e04029eb (Font) Regenerate the bitmap font assets and move them to tools
bitmapfont.bin and bitmapfont.bmp are the source forms of the glyph
data that gfx/bitmapfont.c compiles in: the .bin is the raw 1792
bytes, the .bmp a 256x256 4bpp sheet of 16x16 cells that can be opened
in an image editor. Neither is read at build time or at runtime.

They had drifted. The C array disagreed with the .bin in 104 bytes
across 36 glyphs - %, &, @, ~ and a run through the high Latin-1 range
- because the array had been edited directly and the other two forms
left behind. A source file that disagrees with what it claims to
generate is worse than no source file.

Regenerate both from the C array, which is what actually ships, and
move them to tools/ where build-time inputs belong rather than gfx/
where they looked like part of the driver.

Add tools/bitmapfont_convert.py, which produced them and can convert
in either direction:

    bitmapfont_convert.py export bitmapfont.c --bin F --bmp F
    bitmapfont_convert.py import bitmapfont.bmp --carray F
    bitmapfont_convert.py check  bitmapfont.c bitmapfont.bin bitmapfont.bmp

'check' verifies all three agree, and is what would have caught the
drift. The importer round-trips the exported .bmp back to a
byte-identical array, so editing the sheet and regenerating is now a
supported path rather than folklore.

Also drops the references to these two files from seven Apple Xcode
projects. They pointed at gfx/drivers_font_renderer/, which no longer
holds them.
2026-08-08 05:11:53 +02:00

141 lines
5.5 KiB
Python
Executable File

#!/usr/bin/env python3
"""Convert RetroArch's built-in bitmap font between its three forms.
The font that gfx/bitmapfont.c compiles in is 256 glyphs of 5x10
pixels, one bit per pixel, seven bytes per glyph. Two other
representations of the same data live beside this script:
bitmapfont.bin the raw 1792 bytes, in glyph order
bitmapfont.bmp a 256x256 4bpp sheet, 16x16 cells of 16x16 pixels,
glyph in the top-left 5x10 of each cell, palette
index 1 = ink. This is the form you can edit in an
image editor.
Usage:
bitmapfont_convert.py export <bitmapfont.c> [--bin F] [--bmp F]
bitmapfont_convert.py import <bitmapfont.bmp> [--bin F] [--carray F]
bitmapfont_convert.py check <bitmapfont.c> <bitmapfont.bin> <bitmapfont.bmp>
'check' is the one worth wiring into anything automated: it verifies
all three agree, which they had not for some time - the C array had
been edited directly and the .bin/.bmp left behind.
"""
import sys, re, argparse
GLYPHS, GW, GH = 256, 5, 10
GBYTES = (GW * GH + 7) // 8 # 7
CELL, COLS = 16, 16
DIM = CELL * COLS # 256
def carray_read(path):
s = open(path, encoding='utf-8', errors='surrogateescape').read()
i = s.find('bitmap_bin[%d] = {' % (GLYPHS * GBYTES))
if i < 0:
raise SystemExit('%s: no bitmap_bin[] found' % path)
body = re.sub(r'/\*.*?\*/', '', s[i:s.find('};', i)], flags=re.S)
v = bytes(int(x, 16) for x in re.findall(r'0x([0-9a-fA-F]{2})', body))
if len(v) != GLYPHS * GBYTES:
raise SystemExit('%s: got %d bytes, expected %d'
% (path, len(v), GLYPHS * GBYTES))
return v
def carray_write(data):
out = ['const unsigned char bitmap_bin[%d] = {' % len(data)]
for g in range(GLYPHS):
row = data[g * GBYTES:(g + 1) * GBYTES]
out.append(' ' + ','.join('0x%02x' % b for b in row)
+ ', /* code=0x%02X */' % g)
out.append('};')
return '\n'.join(out) + '\n'
def get_px(data, g, x, y):
p = x + y * GW
return (data[g * GBYTES + (p >> 3)] >> (p & 7)) & 1
def set_px(buf, g, x, y):
p = x + y * GW
buf[g * GBYTES + (p >> 3)] |= 1 << (p & 7)
def bmp_write(data):
stride = (DIM * 4 + 31) // 32 * 4 # 128
pix = bytearray(stride * DIM)
for g in range(GLYPHS):
ox, oy = (g % COLS) * CELL, (g // COLS) * CELL
for y in range(GH):
for x in range(GW):
if not get_px(data, g, x, y):
continue
px, py = ox + x, oy + y
row = DIM - 1 - py # BMP rows are bottom-up
idx = row * stride + (px >> 1)
pix[idx] |= 0x10 if (px & 1) == 0 else 0x01
hdr = bytearray()
hdr += b'BM'
hdr += (62 + len(pix)).to_bytes(4, 'little') + b'\0\0\0\0'
hdr += (62).to_bytes(4, 'little')
hdr += (40).to_bytes(4, 'little')
hdr += DIM.to_bytes(4, 'little') + DIM.to_bytes(4, 'little')
hdr += (1).to_bytes(2, 'little') + (4).to_bytes(2, 'little')
hdr += (0).to_bytes(4, 'little') + len(pix).to_bytes(4, 'little')
hdr += (0).to_bytes(4, 'little') * 2
hdr += (2).to_bytes(4, 'little') + (2).to_bytes(4, 'little')
hdr += bytes((255, 0, 0, 0)) + bytes((255, 255, 255, 0))
return bytes(hdr) + bytes(pix)
def bmp_read(path):
m = open(path, 'rb').read()
if m[:2] != b'BM':
raise SystemExit('%s: not a BMP' % path)
off = int.from_bytes(m[10:14], 'little')
w = int.from_bytes(m[18:22], 'little')
h = int.from_bytes(m[22:26], 'little')
bpp = int.from_bytes(m[28:30], 'little')
if (w, h, bpp) != (DIM, DIM, 4):
raise SystemExit('%s: expected %dx%d 4bpp, got %dx%d %dbpp'
% (path, DIM, DIM, w, h, bpp))
stride = (w * 4 + 31) // 32 * 4
out = bytearray(GLYPHS * GBYTES)
for g in range(GLYPHS):
ox, oy = (g % COLS) * CELL, (g // COLS) * CELL
for y in range(GH):
for x in range(GW):
px, py = ox + x, oy + y
b = m[off + (h - 1 - py) * stride + (px >> 1)]
v = (b >> 4) if (px & 1) == 0 else (b & 0xF)
if v:
set_px(out, g, x, y)
return bytes(out)
def main():
ap = argparse.ArgumentParser(add_help=False)
ap.add_argument('mode', choices=('export', 'import', 'check'))
ap.add_argument('files', nargs='*')
ap.add_argument('--bin'); ap.add_argument('--bmp'); ap.add_argument('--carray')
a = ap.parse_args()
if a.mode == 'export':
data = carray_read(a.files[0])
if a.bin: open(a.bin, 'wb').write(data); print('wrote', a.bin)
if a.bmp: open(a.bmp, 'wb').write(bmp_write(data)); print('wrote', a.bmp)
elif a.mode == 'import':
data = bmp_read(a.files[0])
if a.bin: open(a.bin, 'wb').write(data); print('wrote', a.bin)
if a.carray: open(a.carray, 'w').write(carray_write(data)); print('wrote', a.carray)
else:
c, b, m = (carray_read(a.files[0]),
open(a.files[1], 'rb').read(),
bmp_read(a.files[2]))
ok = True
if c != b:
n = sum(1 for i in range(len(c)) if c[i] != b[i])
print('MISMATCH: C array vs .bin - %d bytes differ' % n); ok = False
if c != m:
n = sum(1 for i in range(len(c)) if c[i] != m[i])
print('MISMATCH: C array vs .bmp - %d bytes differ' % n); ok = False
print('all three agree' if ok else 'sources disagree')
return 0 if ok else 1
return 0
if __name__ == '__main__':
sys.exit(main())