Fractional kerning and advance

[stg]

For systems that render bitmap text with subpixel accuracy, it would be very useful to have kerning and advance values with subpixel accuracy.

I would like to be able to export files with a configurable number of fractional bits for these values (typically called Qn fixed-point format, where n is the number of fractional bits).

This essentially means that all stored values have a factor of 2**n.

For example:
Q0 - exactly as it is today: 1 equals 1 pixel
Q1 - 1 fractional bit: 1 equals 1/2 pixel, 2 equals 1 pixel
Q4 - 4 fractional bits: 1 means 1/16 pixel, 16 means 1 pixel
etcetera.

Typically, for subpixel accuracy, no more than 8 bits are ever wanted, so Q0 to Q8 would be a suitable range.

Reserved bits in Block 2, bitField (where bit 7 is "packed") can be used to indicate the number of fractional bits, which would not break compatibility unless the feature is used. And if it is used, and a parser is unaware, it would lead only to instantly obvious character distance errors.

This would also yield more kerning pairs, as pairs that previously rounded to 0 are now included.

Today, the only way to get this information is to use the following painful process:

• Export 4x (for example) required font size
• Extract kerning and advance information
• Export required final font size
• Inject kerning and advance information back, now with 1/4 subpixel accuracy

I am currently using Q2 (1/4 subpixel accuracy) with very good results, and even though my internal advance and kerning fields are only 8 bits wide, they never overflow with any tested 32px font. These fields are 16 bits in the BMF binary format, so there is plenty of headroom, given that subpixel accuracy is mostly useful with small font sizes.

[SilenceLeo]

Hi @stg ,

Thanks for the detailed explanation.

Just to make sure I understand correctly:
when you mention Q1 / Q2 / Q4, do you mean this would also correspond to a higher-resolution texture atlas (e.g. Q0 = 128×128, Q1 = 256×256 2x)?
Or is the intention just to support fractional precision for kerning and advance values, while keeping the texture size the same?

This will help me determine whether the change should only affect the metric encoding or the whole texture generation process.

🍻

[stg]

No, the texture atlas should remain the same.

What helps with good-looking rendering of small fonts is just sub-pixel metrics for kerning and advance.

What I am doing today is exactly this:

• Generate a font of size 32 - this is the target size that will be used.
• Generate an identical font, but with size 128 (4x size)
• Inject kerning and advance fields from size 128 font => size 32 font.
• Discard size 128 font.

This leaves me with the original size 32 font and its atlas untouched, but now with many more kerning pairs and 1/4 (Q2 - two fractional bits) subpixel accuracy for x-placement of glyphs in a text string. This allows me to advance glyph positions much more accurately. If this is not done, small fonts tend to look like they have weird character spacing and kerning.

Admittedly, this setting is not for every target application, but I do believe this can be beneficial for any application that animates, rotates, or scales text in such a way that characters often end up in non-integer locations, where pixel-to-pixel sharpness is already a non-issue.

In my case, if you are interested in background, I do a lot of rendering on microcontrollers for small displays and LED matrices with exactly such animations. Without subpixel accuracy, text tends to look like it has bad kerning and weird spacing. I sometimes use fonts that are so small that they are nearly unintelligible unless they are animated - the eyes and brain do a fantastic job at reconstructing the shape of a character when it is moving smoothly, even though there are not really enough pixels for clarity at any given time :) This allows me to display text on displays as low as 16 pixels high but with an appearance of much higher resolution, with serifs and other decorative elements clearly visible despite being smaller than a pixel.

[SilenceLeo]

• Generate a font of size 32 - this is the target size that will be used.
• Generate an identical font, but with size 128 (4x size)
• Inject kerning and advance fields from size 128 font => size 32 font.
• Discard size 128 font.

Would it be possible for you to share the three BMF files with me for reference?

[stg]

I can share the font.sbf I am currently working with, and the two BMFont files I generate from it. font.fnt is generated from size 32, and font4x.fnt from size 128, but both from font.sbf with otherwise identical settings.

The resulting (third file) is not available as a .fnt or .sbf since I am not using .fnt files directly, rather a .c resource file.

I can, however include that file and the program that extracts information from both files to get fractional kerning as described and I could create a sample .fnt file if you wish, i would just have to code that up. Let me know.

font.zip

[stg]

Okay here is the example file that I would have loved to be able to get directly from snowb-bmf.
This is an example of (previously uploaded) font.sbf as if it had been exported with size 32 and what would correspond to a setting of Q2 fractional accuracy.

font_q2_example.zip

As you can see all kerning and advance fields now have 2 bits of fractional precision, many more kerning pairs are included, and the unused block 2 bitfield is set to 2.

[stg]

#130 pull request added.