The GeForce 3: Programmable Shaders and the Birth of Modern Graphics

I just saw a demo of the "Zoltar" head running on a GeForce 3, and my jaw is still on the floor. For years, we’ve been stuck with the "Fixed-Function Pipeline." If you wanted to do lighting or texturing, you used the built-in functions the hardware gave you. If you wanted something else—say, realistic skin or rippling water—you were out of luck. The GeForce 3 changes everything with the introduction of the Vertex and Pixel Shader.

For the first time, we have a programmable GPU. We aren't just sending triangles and textures to the card; we’re sending code. This is the birth of what NVIDIA calls the "nfiniteFX" engine.

A Vertex Shader allows you to manipulate the geometry of a 3D model on the fly. Want to make a character’s muscles bulge as they move? Write a shader. A Pixel Shader, on the other hand, operates at the pixel level, allowing for incredibly complex lighting calculations like per-pixel bump mapping (Normal Mapping). The visual difference between the GeForce 2 and the GeForce 3 isn't just a bump in resolution; it's a fundamental shift in the quality of the image.

The challenge, of course, is that we now have to learn a whole new language. Writing assembly code for a GPU is not for the faint of heart. We’re dealing with registers, vector math, and extremely tight constraints. But the payoff is worth it. Games like the upcoming Doom 3 are going to look better than anything we’ve seen in the cinema.

The console world is paying attention too. Rumor has it the upcoming Microsoft Xbox is basically built around this GeForce 3 technology. If that’s true, the line between PCs and consoles is about to blur forever. We are entering the era of "Cinematic Computing," and the fixed-function cards in our machines today are officially relics of the past.

// A hypothetical vertex shader concept (simplified)
struct app2vert {
    float4 position : POSITION;
    float3 normal   : NORMAL;
};

vfconn main(app2vert IN, uniform float4x4 modelViewProj) {
    vfconn OUT;
    OUT.position = mul(modelViewProj, IN.position);
    return OUT;
}

The GPU is no longer just a "drawing" chip; it's a co-processor.