I run into similar 'quantization' challenges when building generative design systems in Python. Sometimes a mathematically 'perfect' alignment on the grid looks optically wrong to the human eye. The anti-aliasing logic described here is a great mental model for handling those edge cases.
When it comes to computer screens, usually set too bright to accommodate varying ambient lightning conditions throughout the day/year, it's not as simple, and I am not sure there is a study to confirm it.
And even if so, any individual's case might be different.
Too bright ambient lighting is better handled with monitor shields, not by increasing the display brightness, especially when the screen is glossy.
not my experience (I prefer not to be flashbanged), but sure
Seems like a much superior tech due the ability to reproduce sharp corners, would be interesting to read why the regular SDF was chosen (there are some reasons, but it's not clear which of those wouldn't apply to MSDF)
The process hasn’t changed much at all in the last 30 years.
The biggest advancement in more than 2 decades came when SDF font rendering was introduced as a graphics technique.
In more modern langauges, this is a solved problem and it's easy to use other people code. In C/C++, it's not. As a relavant example, try using FreeType in your C/C++ project, make sure your solution compiles on Linxu, and Mac, and Windows (and ideally other platforms)
find_package(Freetype REQUIRED)
target_link_libraries(myproject PRIVATE Freetype::Freetype)
A question about efficiency: IIUC, in your initial bitmap rastering implementation, you process a row of target bitmap pixels at once, accumulating a winding number count to know whether the pen should be up or down at each x position. It sounds like you are solving for t given the known x and y positions on every curve segment at every target pixel, and then checking whether t is in the valid range [0, 1). Is that right?
Because if so, I think you could avoid doing most of this computation by using an active edge list. Basically, in an initial step, compute bounds on the y extents of each curve segment -- upper bounds for the max y, lower bounds for the min y. (The max and min y values of all 3 points work fine for these, since a quadratic Bezier curve is fully inside the triangle they form.) For each of the two extents of each curve segment, add a (y position, reference to curve segment, isMin) triple to an array -- so twice as many array elements as curve segments. Then sort the array by y position. Now during the outer rendering loop that steps through increasing y positions, you can maintain an index in this list that steps forward whenever the next element crosses the new y value: Whenever this new element has isMin=true, add the corresponding curve segment to the set of "active segments" that you will solve for; whenever it's false, remove it from this set. This way, you never need to solve for t on the "inactive segments" that you know are bounded out on the y axis, which is probably most of them.
Fixed width monospaced, bitmap fonts.
>Fonts are generally curved, pixels are not. How should we anti-alias glyphs to keep text visually appealing?
Consolas, terminus, unscii, IBM 437 fonts...are implying they are not appealing?
>How should we design a system that respects the different layout rules of different languages (e.g. English vs. Arabic)?
Why?
Pick up a book on type and start up Fontforge, and off you go.
Be careful though, make an early choice if you are going with 3rd order curves or 2nd order (Bezier) curves.
Going through TeXbook and MetaFont books by DEK is also a brilliant way to learn about all this, with note that they do have an explicit bitmap step in.
One correction though:
Computers started with bitmap fonts of different pixel sizes. Your console terminal in Linux is still using that, and nothing stops you from using them ("Fixed" has large Unicode coverage and is usually preinstalled) elsewhere too.So no, none of this tech is necessary for us to read text on computer screens.