Retrocomputing Stack Exchange is a question and answer site for vintage-computer hobbyists interested in restoring, preserving, and using the classic computer and gaming systems of yesteryear. It only takes a minute to sign up.
Sign up to join this community
During a conversation, a friend of mine sent me this picture:
It's the first Thief (I guess), with so-called software rendering.
I already experienced this effect in Quake 1-2 and to an extent, in Shogo: M.A.D., but never actually understood, what it is.
How these settings work, why they produce lower quality and why it diseppeared after the millenia?
“Software rendering” usually refers to 3D rendering which doesn’t use hardware assistance (see Wikipedia for a lengthier description).
Older games only had software renderers; hardware rendering didn’t exist in consumer PCs. In the late 90s, 3D-capable graphics processors became available, including the famous 3Dfx chips, and games started using them — initially via game patches, e.g. the various 3D accelerated patches available for Quake. Eventually hardware-assisted 3D rendering became the default, using OpenGL or Direct3D, but for a few years, games continued to ship with software renderers too; examples include Thief, the early Unreal games... However as hardware renderers increased in capabilities and speed, it became unrealistic to maintain equivalent software renderers running at an acceptable speed, and game developers stopped building software renderers.
During the intermediate phase, when hardware renderers and software renderers were both available, quality varied; early hardware renderers weren’t always all that good (see for example the various renderers available in Tomb Raider), and significant effort was spent on certain software renderers (Unreal’s was particularly impressive). As time wore on though, developers produces better hardware-assisted rendering engines, hardware accelerators improved, and less time was spent on software renderers, resulting in the quality differences you’re seeing. This is still visible on older engines today: Quake or Quake II on a recent GPU are much nicer to play than they were when they first came out! (And yes, the engines have been tweaked since then, but the core is fundamentally unchanged.)
The Mode is called software rendering, because the program is painting all pixels with the CPU. So you are not using a 3D-Interface like OpenGL or DirectX (which interfaces with 3D-hardware) but set single Pixels (aka Bytes) in a framebuffer(a rectangle part of your Memory you usually copy to your Graphics card)
Why is it so ugly?
Because the CPU was busy painting the triangles with (sometimes affine) texturemapping into the memory. There was simply no time to do transparency (which needs reading the already painted pixel and multiplying!) or antialiasing(which is even more costly).
Taking as given: software rendering uses the general-purpose CPU to paint pixels rather than a dedicated GPU; the general-purpose device has less ability because it's not optimised for the job; writing two sets of code rather than one is more work and GPUs became commonplace so the worse option died out.
Then the specific flaws you're seeing in that image — to answer "why they produce lower quality" — are lack of texture filtering and very harsh geometry edges.
When deciding which colour to make a screen pixel, both the CPU and the GPU know which point on the original textured surface is visible there. That's where processing diverges. It is very unlikely that the point on the original surface falls exactly on the centre of a pixel in the texture.
A 3d accelerator of the period is likely to have time to perform bilinear or trilinear filtering. Bilinear filtering samples all four texture pixels that surround the point being output, then calculates a weighted sum. So that's four texture lookups, six multiplies and a summation. Trilinear filtering does that twice with two different resolutions of texture and calculates the weighted sum of the results, for eight texture lookups and thirteen multiples.
That's far too much work for a CPU. So it just figures out which source pixel is closest to the point and outputs that.
The difference is between textures that when stretched too large obviously show their individual pixels as boxes, and surfaces that just look very blurry.
In that era, harsher geometry edges result from the CPU just not being fast enough to draw the same number of pixels as a 3d accelerator. So a lower screen resolution is used. They also tend to run at a slower frame rate, which makes the effect more apparent. Several 3d accelerators of the period support edge blending as a way to eliminate rough edges, which uses per-pixel weighted transparency on each edge pixel, but that's not as useful as it sounds because it presupposes you're drawing all geometry from back to front and therefore doesn't interact very well with engines built around z-buffering.
The posted screenshot doesn't show these problems, but other divergences you might see in contemporaneous titles:
OpenGL, Direct3D and so on take advantage of hardware 3D accelerators which can draw 3D scenes much more quickly than the CPU can do by itself. So to maintain acceptable frame rates, scenes rendered in software with the CPU must be much more simple (easier on the CPU) than scenes rendered in hardware.
