Evaluate Slug

[bjornbytes]

Maybe we can replace MSDF with Slug (Slug is patent-free now!). MSDF might still be good for certain effects like outlines though. Not hard to roll it yourself with a msdf-atlas-gen'd BMFont + shader?

[jamesthomasgriffin]

I've had a look at the original paper (and the March 26 blog post which describes changes since then). The method seems to produce correct results with no artifacts. I do have two concerns:

1. Small text rendering; the only way to get good results directly is to use multiple samples, but this exacerbates the second concern.

2. Performance; the quoted render times are fairly large for a page of text with a simple font and becomes unacceptable for a intricate font. Also this poor performance may apply for a single glyph filling the page.

The simplest fix for small text is to have a separate mipmapped atlas of rasterised text. For scripts with a large number of glyphs these would need to be dynamically loaded, somewhat removing a main advantage of the algorithm.

The fix for performance is probably more caching. Instead of using bands, divide the glyphs into a grid, recording the winding number for each rectangle center then only intersecting the curves from this center. This probably gives a hefty boost, especially for intricate glyphs. It comes at the expense of memory.

[jamesthomasgriffin]

https://github.com/jamesthomasgriffin/robin

This demo should help evaluate SLUG, but it's my own implementation using the caching suggested previously. You can toggle between Robin and MSDF to see the performance differences (EDIT: fixed just a warning, the information at the top of the demo screen is always rendered using Robin, perhaps I'll change that).

On my laptop (nvidia mx150) I find that Robin is about 4-5x slower than rendering using MSDF. For all but the simplest of fonts the quality is much higher and MSDF has loads of artefacts on some fonts, in particular CJK. I'm actually a bit surprised that I see such a small factor given that the MSDF approach is so fast. This factor is similar across different fonts. Loading fonts should be much faster using Robin, it's basically just standard black and white rasterisation and the rasters are much smaller.

Comparing against SLUG is harder for two reasons: first, SLUG is heavily dependent on the number of curves in a glyph, so the results are different for different fonts. Second, I don't have a full SLUG implementation, I can set my raster to 1x64 and this performs pretty much the same calculation as SLUG in the same way. However there are a few optimisations that the full implementation of SLUG uses, which are superfluous for a square raster, but would speed up the 1xn case. So for very simple fonts I expect SLUG would be about the same speed as ROBIN, but for anything more intricate ROBIN is much faster with comparable memory use.

I'd encourage anyone reading this to download a selection of fonts from Google Fonts and then try the demo themselves.