What operations could early PC 3D accelerators perform?

Question

As I understand it, a modern GPU is actually just a Turing-complete processor which happens to be heavily optimised for massively data-parallel workloads. (You can even buy "graphics cards" that don't generate any graphics!)

As I understand it, earlier graphics accelerators such as the legendary Voodoo 2 were fixed-function devices, hard-wired to do only 1 thing, but do it extremely fast. Back in those days, what features your games could have depended on your graphics card. If (for example) your graphics card doesn't have trilinear filtering, you can't have trilinear filtering! End of discussion. So (as I recall it) each new GPU would shout about all the fancy new features it has. [Today, of course, that's all a function of the software you're running, not the hardware that runs it. Oh, wait... hello RTX!]

What I'd like to know is, what did these fixed-function devices actually do? Which exact parts of the rendering pipeline are done by the GPU, and what still needs to be done by the CPU? I presume perspective projection and Z-buffering is done in hardware on the GPU. What else? When you turn around, who rotates the entire world mesh? The CPU or the GPU? Does the CPU say "render this polygon please" for each individual polygon? Or does it upload an entire mesh into the GPU's memory and say "render this mesh" each frame?

Answer 1

Having owned a Voodoo 1 back in the day, it did pixel painting only, and was slightly buggy in that.

The CPU's job was to transform, clip and project all geometry, and to have transferred any necessary textures to the GPU at some point. Vertex attributes were then supplied to the GPU for rendering — screen location and depth, texture coordinates and colour. The original Voodoo was a single-texturing GPU only, so e.g. Quake's light maps are achieved in two passes.

The GPU then did all per-pixel operations — texture mapping, Gouraud shading, optionally fog, and z-buffering. Every one of those steps was optional. Edge anti-aliasing was also available, but in the sense of computing alpha based on pixel coverage and rendering as a partially-translucent pixel. So geometry ordering became a factor.

Furthermore, the GPU had a slight bug in its handling subpixel precision for vertex locations so you had to snap them to 1/16th of a pixel boundaries.

This is all pretty similar to what the GPU in the PlayStation offered, although it is fixed-point only, doesn't offer perspective-correct texturing or subpixel placement of vertices, doesn't do per-pixel fog or z-buffering, and has a much more limited sense of transparency. On the other hand, it's much more flexible in terms of using tiny source textures, or portions of them, with local palettes and optional mirroring repeat patterns; meanwhile the CPU has a dedicated 3d maths coprocessor attached. There's also quite a bit more there for DMA transfer of geometry lists — the usual sort of stuff you'd expect from a graphics-dedicated architecture.

Answer 2

What did old-style GPUs actually do?

As so often, when it comes to early 3D, Fabian Sangland's website is a good source. Here for example an article about 3dfx' Voodoo 1/2 cards: The Story of the 3DFX Voodoo 1

Linke mentioned in comments, best way to get an idea about what are the steps that can be moved between units is looking at OpenGL. In general, the most regular function that get repeated most often are the ones that got moved to GPU first. A clear winner for this is texture mapping. It's a rather simple series of lookup operations were triangle coordinates get transformed into memory addresses giving texture data to be outputted in raster lines.

I presume perspective projection and Z-buffering is done in hardware on the GPU.

Nop, well, it did Z-buffering, as that is as well an easy lookup operation (in fact it used most of its RAM bandwidth). Voodoo 1 is a rather stupid texture engine (with transparency). It does texture filtering. Triangles had to be feed in screen coordinates which get textures applied and each resulting pixel checked for depth (Z-buffer) before written to screen memory.

Everything before that had to be done on the CPU - plus as much filtering of obscured objects as possible, as the sustained triangle rate of a Voodoo 1 was about 550k/s, so with 30 fps (which was awesome at the time) a scene should be well below 15k triangles. Quite awesome for back then, but also showing why good texture design was way more of an art back then than today.

The Voodoo 2 was not much different, except faster (3M triangles/s) and able to apply two textures at once. This enabled the use of a basic texture and a lighting texture in one pass. This was, depending on engine and content a sped up of up to 10 times for complex scenes.

---

When you turn around, who rotates the entire world mesh?

The CPU.

Does the CPU say "render this polygon please" for each individual polygon?

Even more primitive, the CPU has to turn polygons first into triangles and feed the Voodoo 1/2 with those.

Or does it upload an entire mesh into the GPU's memory and say "render this mesh" each frame?

Nop, this was something that added to 3dfx' downfall, as Nvidia implemented this first for their GeForce 256 (IIRC) - the Starting point when GPU became more flexible.