hckrnws

Thanks for sharing! Author here, happy to answer any questions.

Google Maps uses AAA on capsule shapes for all road segments - I wrote it ~10 years ago. :D

Neat. Does that mean that every road segment is a separate mesh?

Depends on what you mean by "mesh". Each road segment is an instanced rectangle that gets extruded and beveled so that it fits tightly against adjacent segments, and then the pixels are shaded using AAA (with a capsule-shaped distance field) so that the result looks like an antialiased wide line with round end caps and joints.

This brought back some memories. Long ago I had to do some AAA for line rendering on some hardware that didn't support line AA natively.

A big customer was furious that they had bought a part that didn't perform the way they wanted, so I was voluntold to fix it.

I was given a ridiculous timeframe to come up with a solution and present them to our customer in a big in-person meeting with all the decision makers. I managed to implement three different alternatives so that the customer would feel they had some agency selecting the one they liked the most. The best looking by far was a form of AAA.

This was one out of several of these big last minute fires I was assigned to solve. Years later my manager told me how great it was knowing that the could throw any crap at me and I would be able to fix it in time.

However, these sort of experiences are why I struggled with burnout during my career, which led me to save like crazy to retire as early as possible, which I did.

For younglings out there: when they ask you to do the impossible, remember that failure IS an option. Push back if you think they are asking you for something unreasonable.

Great story and useful lesson, thanks for sharing.

Also, going to add "voluntold" to my lexicon :D

Fantastic article! I've been trying to figure out antialiasing for MSDF fonts, and have run across some claims:

1. antialiasing should be done in linear rgb space instead of srgb space [1] [2]

2. because of the lack of (1) for decades, fonts have been tweaked to compensate, so sometimes srgb is better [3] [4]

Do you have advice on linear vs srgb space antialiasing?

[1] https://www.puredevsoftware.com/blog/2019/01/22/sub-pixel-ga...

[2] http://hikogui.org/2022/10/24/the-trouble-with-anti-aliasing...

[3] https://news.ycombinator.com/item?id=12023985

[4] http://hikogui.org/2022/10/24/the-trouble-with-anti-aliasing...

> Do you have advice on linear vs srgb space antialiasing?

Unfortunately, this is completely context dependent. One central point is, whether or not the graphics pipeline is instructed to perform corrections (GL_FRAMEBUFFER_SRGB in OpenGL), as that changes the answer. Another point is, in which context blending is performed. Luckily the developer has full freedom here and can even specify separate blending for alpha and color [1], something that GPU accelerated terminal emulator Alacritty makes use of [2], though it doesn't do MSDF rendering.

One thing I can say though: The alpha, the fading of edge, has to be linear at the end or perceived as such. Or rather if the edge were to be stretched to 10 pixels, each pixel has to be a 0.1 alpha step. (If smoothstep is used, the alpha has to follow that curve at the end) Otherwise the Anti-Aliasing will be strongly diminished. This is something you can always verify at the end. Correct blending of colors is of course a headache and context specific.

> fonts have been tweaked to compensate, so sometimes srgb is better

This should not concern MSDF rendering. These tweaks happened at specific resolutions with monitors popular at that time. Especially when considering HiDPI modes of modern window systems, all bets are off, DPI scaling completely overthrows any of that. MSDF is size independent and the "tweaks" are mainly thickness adjustments, which MSDF has control over. So if the font doesn't match as it looks in another rendering type, MSDF can correct for it.

[1] https://developer.mozilla.org/en-US/docs/Web/API/WebGLRender...

[2] https://github.com/search?q=repo%3Aalacritty%2Falacritty+ble...

Great post! Minor nitpick: WebGL does support MSAA since WebGL1, but in WebGL1 only on the canvas, and you don't have any control over the number of samples (can only select antialiasing on/off) - not that it matters much anymore :)

What WebGL2 is still missing is MSAA texture objects (it only supports MSAA render buffers), which makes it impossible to directly load individual samples in a shader (useful for custom-resolve render passes). That's only possible in WebGPU.

How long did this take to write?

I have done a few live visualization based blog posts, and they take me ages to do. I kind of think that's the right idea though. There is so much content out there, taking longer to produce less content at a higher quality benefits everyone.

The commit history [1] reveals that, took a while. I don't write professionally, something I do in lunch breaks from time to time. Thanks for the kind words.

[1] https://github.com/FrostKiwi/treasurechest/commits/main/post...

One small bit of tecnical feedback for the website itself: it would be nice if the links in the article open in a new tab by default, because reloading the webpage via the back button is a little broken on my mobile browsers. I suspect it has something to do with trying to restore the state of the page while also having WebGL contexts.

Ohh right! I'm sure the must be an Eleventy setting for that...

As a non-gamedev person but just gamer, I should expect that this will replace TAA anytime soon? Should it replace TAA?

Basically no... Analytic AA is a really hard problem for video games, and I know of no general purpose solutions.

For font and 2D vector rendering it's likely, in fact afaik, some solutions, such as Slug already do.

But for 3d rendering I don't know of any solutions.

For an intuition, consider two triangles that intersect the same pixel.

Consider if say one has 20% coverage and the other 30%, does that pixel have 50% coverage, 30% by one, 20% by one and 10% by another, or any other conceivable mix? It's very difficult to say without selecting specific points and sampling directly.

Great write up, excellent explorables. I skimmed some parts so forgive me if this was covered, but I wonder what happens with overlapping shapes in this approach. For example, a white background with a black disc and then a white disc of the exact same size and position would probably leave a fuzzy gray hairline circle? With regular antialiasing it should be all white.

What happens during overlap, is something you control fully, at every step. (Except when using this with MSAA, as that is implementation defined) How intersections happen when blending shapes of multiple draw calls or multiple quads is defined by the blending function you set before issuing the draw call. In WebGL the call is blendFunc() [1] and there are a bunch of options.

How to blend multiple shapes on the same quad, within a draw call is shown in the section "Drawing multiple?". There you fully control the intersection with the blending math.

Finally, there is always the gamma question, which is true for all AA solutions. This is not covered in the post, but that might mess with the results, as is true for any kind of blending.

[1] https://developer.mozilla.org/en-US/docs/Web/API/WebGLRender...

I think the point is that a correct analytical result needs to be computed for all shapes at once. You can't composite overlapping shapes individually, since the alpha value (subpixel coverage), even if analytically correct, is lossy; you lose the information about the exact subpixel geometry, which is needed to do correct compositing (eg. does this shape completely occlude this other one within this pixel?). The standard Porter-Duff blend function assumes the subpixel geometry is a uniform random mist, which is not necessarily a great assumption for AA.

Massive thanks for this! I’m already using my own version of analytical antialiasing but there were some bits I couldn’t get quite right so this is perfect!

Not a question but some unsolicited (sorry) feedback. The intro seems designed to set people up for disappointment. You start off by talking about AA methods used for 3D scenes, and you've picked a very cool way to present them... but the article is actually about antialiased drawing of SDFs, which is not exactly a hard problem and not applicable to 3D scenes. Unless your scene is made up of SDF shapes, but I don't think the method you're presenting would be fast enough on a nontrivial scene as you would need to rely on alpha-blending across seams. (I think Alex Evans' talk on Dreams mentions they tried something similar to get fuzzy shapes but dropped it due to perf and sorting issues.) In any case, it would have been nice for the article's intro to more clearly say what it's about and what the technique is useful for.

True, this is something I struggled with writing and ended up with just a small note commenting that this is not widely applicable. Will clarify more in coming posts. It's all incredibly context specific. The reason for this order, is that you can very much can use all these approaches (SSAA, FXAA, MSAA etc.) for rendering simpler shapes and HUDs. So going through them, where these approaches break down and when it does make sense to go the extra mile with SDFs.

Still, non-standard rendering approaches are very much a thing [1] and I could see setups like [2] be used in scientific particle visualizations.

[1] https://www.youtube.com/watch?v=9U0XVdvQwAI

[2] https://bgolus.medium.com/rendering-a-sphere-on-a-quad-13c92...

Can you elaborate a bit on the tech-stack used for this blog? I didn't find any hints in the source (but I'm not an expert). Is it some known framework? What does the input look like (Markdown etc).?

The blog is built with eleventy https://www.11ty.dev/ and as the previous reply already mentioned, the source code is on GitHub [2]. All posts are single Markdown file each with HTML inserted where I need it. The javascript for the demos is custom and changes from post to post. The basic style comes from Sakura CSS [3] with a bunch of custom stuff on top.

[1] https://www.11ty.dev/

[2] https://github.com/FrostKiwi/treasurechest

[3] https://github.com/oxalorg/sakura

Not the parent, but seems this is the source code for the blog. https://github.com/FrostKiwi/treasurechest

Found it by going to the comments since the comments are GitHub issues the "x comment" is a link to the issues page.

I would love to connect on some ideas around using antialiasing as a way to extend inference in extracting information from computer vision outputs.

> Mobile chips support exactly MSAAx4 [...] the driver will force 4x anyways

On what GPUs and through what APIs did you see this? This seems fairly weird. I especially wouldn't expect Apple to have problems.

Yes, that also surprised me and I tested it on multiple mobile Apple devices. It's not really a mistake per se, the implementation is free to do what it wants. Selecting MSAAx2 on these types of mobile GPUs simply has no upside and isn't really supported over MSAAx4 and I guess apple still wanted to make the choice somehow possible, as opposed to Android, where there is only an illusion of choice.

It's just so happens to produce visible artifacts in this case. I suppose for 3D scenes it's mostly fine.

I’m definitely seeing similar artifacts when at 2x on an iPhone 15 Pro.

Through Metal or in a web browser? Apple's docs say it's supposed to use the standard 0.75/0.25 sample positions with 2x MSAA: https://developer.apple.com/documentation/metal/mtldevice/28...

Viewing the article in Safari.

What an absolutely fantastic read.

Tangent: my biggest problem with AA is something adjacent to it, which is that almost none of my games bother explain what the differences are between the different abbreviations available in the settings, half of which are completely unknown to me. Like, sure, I can look them up but a little bit of user-friendliness would be appreciated.

This article will probably help for future reference though!

Games/graphics are one of those domains with a lot of jargon for sure. If you don't want to be a wizard you can just mess with it and see what happens. I like how dolphin approaches this with extensive tooltips in the settings, but there's always going to be some implicit knowledge.

On a meta level - I feel like I've seen anti-acronym sentiment a lot recently. I feel like it's never been easier to look these things up. There's definitely levels of acronyms which are anti-learning or a kind of protectionism, but to my mind there are appropriate levels of it to use because you have to label concepts at a useful level to accomplish things, and graphics settings of a game definitely are on the reasonable side.

> just mess with it and see what happens

And even if you know every detail, that's still the best course of action, I think. Which kind of antialiasing you prefer, and how it trades with performance and resolution is highly subjective, and it can be "none".

There are 3 components to rescaling/rendering pixels: aliasing, sharpness and locality. Aliasing is, well, aliasing, sharpness is the opposite of blurriness, and locality is about these "ringing" artefacts you often see in highly compressed images and videos. You can't be perfect on all three. Disabling antialiasing gives you the sharpest image with no ringing artefacts, but you get these ugly staircase effects. Typical antialiasing trades this for blurriness, in fact, FXAA is literally a (selective) blur, that's why some people don't like it. More advanced algorithms can give you both antialiasing and sharpness, but you will get these ringing artefacts. The best of course is to increase resolution until none of these effects become noticeable, but you need the hardware.

The best algorithms attempt to find a good looking balance between all these factors and performance, but "good looking" is subjective, that's why your best bet is to try for yourself. Or just keep the defaults, as it is likely to be set to what the majority of the people prefer.

The PS4 Pro introduced the gaming world to the simplification of settings from dozens of acronyms that were common to PC Gamers, down to “Performance” and “Quality”.

I wouldn’t be surprised if there’s now a market demand for that to spread back to PC land.

PC games have had Low, Medium, High presets for graphics settings for decades. I don't think reducing that from 3 choices to 2 is going to be a big win for user friendliness. And I certainly think it's user-hostile if it means taking the customization away and only letting users choose between two presets.

PlayStation does have shining examples of user-friendly settings UI though, namely in their PC ports. Look at this UI in Ratchet and Clank:

https://x.com/digitalfoundry/status/1684221473819447298

Extensive tooltips for each option and any time you change a setting it is applied immediately to the paused game while you're still in the settings menu allowing you to immediately compare the effects.

Nixxes are very enthusiastic about every PC port having proper settings and exclusive options. I hope the C-levels at Sony continue to not notice.

> I don't think reducing that from 3 choices to 2 is going to be a big win for user friendliness

It’s nowhere near as simple as 3 settings now there are different antialiasing techniques, path tracing lighting or reflections, upscaling (multiple algorithms) etc.

Nothing is all just fully positive and each has tradeoffs

Those are typically incorporated into the presets. I am not just talking about Low, Medium, High for individual settings. There's almost always a preset option that will set all the other settings according to what's deemed appropriate by the developer for the selected quality level.

Graphics programming analysis done using examples written in WebGL–genius. Hypertext that takes full advantage of the medium. This reminds me of something I'd see on https://pudding.cool/, but it goes far more in depth than anything there. Absolutely fantastic article.

I've been using MSAAx4 in my rendering engine for some time and only recently have considered switching to a FXAA / TAA implementation. I'm actually not sure I'm going to go through with that now. I definitely learned a lot here, and will probably use the analytical approach for UI items, I hadn't heard about that anywhere.

Not often you see graphics-programming stuff on HN. For anyone interested in more graphics write-ups, this list of frame breakdowns is one of my favorite resources:

https://www.adriancourreges.com/blog/

Steve Wittens also does a lot of these kinds of articles (math with WebGL-infused illustrations, etc.) at https://acko.net/

One of my favorites: https://acko.net/blog/how-to-fold-a-julia-fractal/. This helped me understand the relationship between trigonometric functions and complex numbers like nothing else I've ever seen.

I really dislike TAA, especially on lower framerates. There's too much ghosting. I often switch it to a slower algorithm just so I don't get ghosting.

It’s very strange. I had a vivid dream, only about 5 hours ago, where I was debating the drawbacks of TAA with some scientists in a lab (likely because Half Life has been in the news this week). I think I dream about rendering algorithms once every several years.

And now today there’s this post and your comment here in the front page.

As randomly connected graphs fill in, they quickly must produce patterns. The patterns are non-random (thus they are a pattern!), but essentially "chosen" from all possible patterns randomly.

Which is another way of saying: a proof of God would be going through life without a constant stream of surprisingly meaningful coincidences.

Unbiased reality is inherently a blind but inventive "Creator".

My feeling is if I can render at 4K I can just not do AA at all. It really looks quite fine without, at least for me.

Yes, on high density displays this is very much possible. Eye based SSAA, the worse your prescription the better the quality. On my Pixel 9 Pro, the no AA circle demo is perfect on native 1440p resolution without AA. But dense foliage in 3D scenes will definitely ruin that. Motion induced shimmering is inescapable I think, without some kind of filtering.

No AA on 4K/high-DPI has been almost perfect for me, but I still occasionally notice thin edges flickering and objects getting dithered when fading in or out. It's definitely better than TAA though, which just ends up smearing everything that moves.

I tried that initially, but I found that it still wasn't quite satisfactory. My game's art style has a lot of straight edges, to be fair.

Awesome article.

SDF(or mSDF) isn't the future. It's already "good enough" classic.

> This works, but performance tanks hard, as we solve every > bezier curve segment per pixel

This is "the future" or even present as used in Slug and DirectWrite with great performance

https://sluglibrary.com/ https://learn.microsoft.com/en-us/windows/win32/directwrite/...

Don't forget about implicit curve rendering [0]. The patent will expire soon [1].

[0]: https://www.microsoft.com/en-us/research/wp-content/uploads/... [1]: https://patents.google.com/patent/US20070097123A1/en

I wrote an implementation of the Loop/Blinn paper for Microsoft Game Studios ~20 years ago, I wonder if they're still using it.

Had to do a _lot_ of work to make it production-ready, as their voronoi-based tesselation goes pathological on a lot of Asian glyphs.

I may be remembering totally wrong, but isn't the algorithm used in Slug patented?

https://news.ycombinator.com/item?id=42194175

Appreciated that link out to Captain Disillusion. I had not heard of that guy. Incredible work, here's a direct link for those interested in video effects: https://www.youtube.com/@CaptainDisillusion

Those frames with the circle and zoomed bit are a fantastic way to convey this message, well done the whole article reads great.

Great write-up!

Though a little caveat from my side, as I have written both 2D and 3D rendering engines. Let me tell you, they could not be more different. It is not just another dimension but completely different goals, use-cases and expectations.

So instead of:

> Everything we talked about extends to the 3D case as well.

I would say the entire post is mostly about 3D, not 2D rendering. If you are curious about this topic being approached for 2D rendering here is a nice write-up I found about that: https://ciechanow.ski/alpha-compositing/

One particular criteria for AA techniques that no one cares about in 3D but is very relevant in 2D is correctness and bias. AAA for example is heavily biased and thus incorrect. Drawing the exact same shape multiple times in the same place will make it more opaque / darker. The same thing does not happen with MSAA which has a bounded error and is unbiased.

Hey, i'm brainstorming for a 3d vector renderer in WebGPU on JS/TS and stumbled on your project [0] yesterday.

(Thick) line drawing is especially interesting to me, since it's hard [1].

I also stumbled upon this [2] recently and then wondered if i could use that technique for every shape, by converting it to quadratic bezier curve segments.

Do you think that's a path to follow?

[0] https://github.com/Lichtso/contrast_renderer

[1] https://mattdesl.svbtle.com/drawing-lines-is-hard

[2] https://scribe.rip/@evanwallace/easy-scalable-text-rendering...

My implementation does:

- Implicit Curve Rendering (Loop-Blinn) and stencil geometry (tessellation-less) for filling

- Polygonization (with tangent space parameter distribution) of offset curves for stroking

> by converting it to quadratic bezier curve segments

Mathematically, the offset curve of a bezier curve is not a bezier curve of the same degree in the general case (exceptions are trivial cases like straight lines, circles and ellipses). Instead you get terrible high degree polynomials. You will have to approximate the offset curve anyway. I choose to use polygons (straight line segments), but you could also use splines (bezier segments), it is just overtly complex for little to no benefit IMO.

BTW, distance fields and offset curves are very similar. In fact the distance field is the set of all possible offsets of offset curves and the offset curves are the isolines on the distance field.

Here is a good summary of all the edge cases to think about in 2D rendering: https://www.slideshare.net/slideshow/22pathrender/12494534

About subpixel AA: Don't bother, LCDs are on the down trend.

> About subpixel AA: Don't bother, LCDs are on the down trend.

OLEDs have subpixels, too. The real problem is the growing diversity in subpixel arrangements, making it impractical to have a good subpixel AA method for every display type on the market. And mobile platforms have it worse, because screen rotation means you need to be able to change AA methods on the fly.

Thank you very much for the hints! This rabbit hole gets deeper every day. :D

I don't think the article generalizes trivially to 3D, though.

The solution presented relies on signed distance fields, yet skims over the important part - a distance to what? In 2D it is obvious, we are measuring distance to an edge between the object and its background, to a silhouette.

In 3D, when objects may rotate producing self-occlusions, things get more complicated - what are we measuring the SDF against? The silhouette of a 3D object's 2D projection is ever-changing and cannot be trivially precomputed.

scrolling thru the post the NeoTokyo screenshot struck me instantly, I ran through the hallway thousands of times - I ran a server for that mod for some years and had great fun with a small community of good/capable people.

those buttery smooth gradients are soooo pleasing to watch <3

I've been so used to screen space techniques that I initially read SSAA as "screen space antialiasing", not "super sampled antialiasing".

My favorite is stil SSSSS, or screen space sub surface scattering.

amazing blog, both in content and presentation. Love it when articles give you controls to play with. Gives me hope for the future of the web. the NeoTokyo mention reveals great taste.

I really miss MSAA. I still dislike DLSS personally. I realize many people seem to like it, but it just does not look that good to me. Or as good as things used to look or I believe could look.

Sure it's better than TAA, but come on, this can't be the ultimate end for gaming graphics... At least I hope it isn't.

The problem with MSAA is that it only handles aliasing from geometry edges. It's pretty much useless against shader aliasing, which became a massive problem after normal mapping and HDR lighting became standard in the PS3 era.

Same here. I can't put my finger on what exactly it is, but it just never feels and looks as good as lower quality at full resolution.

Now I'm very curious about analytical AO and shadows as you mentioned Last Of Us uses. I'd heard about the spheres but never seen an explanation of how they get turned into shadows

What's the catch?

The catch is the alpha-blending, which is something modern games avoid doing as much as possible which is why so many games use that dither-pattern transparency you may have seen before.

To do alpha blending correctly you need to blend with what's behind the object. But what if you haven't rendered what's behind the object? You won't have anything to blend with!

This means you first have to sort all the objects you're rendering and render them in-order. It also means you can't use a depth pre-pass because you need to draw what's behind the object even for the parts you already know will be covered by the object in front of it. There's a bunch of more reasons to avoid it, but those are some of the basic ones.

An alternative is to draw only a few pixels of what's behind the object you're rendering at the edges of the object that's in front and then alpha blend those extra samples together, which seems to be the solution proposed in the article for actual 3D games. So then the catch is that you're doing MSAA, just with high-quality blending rather than the standard averaging of the samples.

Now that I am delving into the retro-gaming world, I find it funny that 30 years ago gamers lambasted the Sega Saturn for using dithering patterns instead of proper transparencies, only for the same technique to come back decades later.

> Mobile chips support exactly MSAAx4 and things are weird. Android will let you pick 2x, but the driver will force 4x anyways.

Hmm... On my Android phone I definitely see a difference between 2x and 4x, but it's not "rounded" like the iPhone one.

[flagged]