alt Hacker News> This is incorrect
Incorrect how? It's correct in that software renderers of the time TFA describes mostly looked like this, and GPU renderers didn't (of course, they weren't called GPUs back then), and there's a reason for this. Even you admit it later in your comment.
So saying "it has nothing to do" with software renderers (of the time) is wrong. It has something to do with how software renderers vs GPUs were used during that era in practice. It's also true you can simulate one with the other, but that doesn't make it incorrect or unrelated.
> So to show off, every 3D game back then turned it on (an OpenGL/Glide/D3D configuration option) and everything got smoothed out, often with no option to turn it off. That's why it ends up looking different
So it had something to do after all! So TFA has a point. He means software renderers in the sense you're describing here, and it's clear from the text. He's not implying you cannot use a GPU to achieve the same result.
Replies
This is ridiculous. He explained it perfectly and he was right stating that it has "nothing to do with software rendering". The fact that people specifically chose to do it differently on hardware makes nothing about what the article mentions specific to software rendering. Otherwise if you do the smoothing on the CPU you have to call it a hardware renderer now to be consistent.
Software renderers can do bilinear filtering. It does not change any aspect of how the software renderer works. I’ve implemented this, so I know: it’s a couple of lines change in the texture lookup. But it adds three lerps per channel, per pixel, whereas nearest neighbor requires none. That’s 9 multiply-adds in the tightest inner loop that would normally have zero. In the 3D accelerators of the era, the pipelines were all fixed-function (programmability is why NVIDIA renamed it GPU when they released the GeForce 256), so those lerps were in the silicon whether you used them or not. Bilinear filtering had zero impact on render speed, so long as you weren’t saturating video RAM with the added texture lookups.
TL;DR a software rendered game and a 3D accelerated game from that era looked VERY different, but that difference was largely down to a feature that was often implemented in the software renderer, and was only a couple of lines in the innermost loop. But rarely used outside of a few choice effects due to the massive performance impacts. On 3D accelerators it was free, and default-on.
(I’m an old fart that cut my teeth in programming writing software renderers with the community at Flipcode, if anyone remembers that.)