How can I render fonts in a game with correct hinting?

Question

I've used angel code's bitmap font generator quite a bit; though it's very good, I wonder if there would be a way to use the hinting information to provide a better and more readable result, by using hinting to provide differing thickness based on size/pixel coverage.

I imagine any solution would have to use the distance field tech presented in the valve paper on smoothing fonts while maintaining or reducing asset size. I haven't found any demos of it being used with hinting information turned on, or included in the field gradients in any way.

Another way of looking at this is whether there are any font bitmap generators that will output mipmaps that still maintain their readability in the face of pixel size. I think the lower mip levels would try to guarantee fill and space where it is necessary to maintain readability/topology over maintaining style/form; the point of hinting.

---

Is there a reason you can't just render the size you want?

The problem lies in the fact that font rasterisers currently don't render in 3D, and hinting information would be important in different amounts, due to the pixel density being different along different axes; even differing in importance along the length of a string, due to the size reducing over distance. For example, I only want horizontal hinting in a texture that is viewed from the side, and only really want vertical hinting in a font that is viewed from below or above. This isn't meant to be a renderer that tries to render a perfect outline as accurately as possible, as hinting distorts the reality of the font; instead, this is meant to be a rendering solution for static scenes, where the scenes use 3D transformed and warped text layout. In this case, the legibility is important; more important than the accuracy of representation of the polygon shape.

Answer 1

My only good suggestion is to try making the thresholds in the distance field technique a function of the desired character size or (somewhat equivalently) the ratio between the rendered size and the desired size. (I think this is mathematically equivalent to applying a non-linear filter when scaling.) That would drastically increase the cost of the fragment shader (though maybe not significantly in a real program), and you'd end up duplicating non-trivial code if you also wanted a fixed-function path.

Another possibility would be to average the distance field across many font sizes while generating it, which would get you the hinting information "in" the texture. However, usually the distance fields store between 32px and 64px per character. The cases where manual hinting truly benefits is at small (8-16px) font sizes. I don't know how much meaningful information there is to get from averaging something intended for ~8px with something intended for ~256px and storing it in ~32px.

Any other techniques I can think of require more memory, at which point you're really better off just rendering the fonts in the size you want, and using them as-is.

Answer 2

IANAL, but the hinting patents have recently expired. A TrueType implementation, such as FreeType should be usable with hinting enabled.

My group has built our own TrueType rasterizer, although I know several teams that are satisfied with the degraded quality found in the distance field technique (largely because they're using simple sans-serif fonts in simple situations such as subtitles and decals).

All that said, most fonts have crummy auto-generated hints in them. Stick to the major type houses or you'll just be looking at the output of FontLab.

Although we knew the hinting patents were expiring, we did not implement a bytecode interpreter because we felt that the small sizes where hints are most designed to help shouldn't be used on game consoles, which is what we target.