Visiontek GeForce 3 Review

Dronez Information

This content was originally featured on Amdmb.com and has been converted to PC Perspective’s website. Some color changes and flaws may appear.

Understanding benchmark modes
DroneZ uses an illumination system and bump mapping method that cannot be implemented in hardware on previous video cards.
The intention to put place advanced features in hardware is what inspired nVidia to create the nFiniteFX engine!
The GeForce 3 is the only card that can handle a custom illumination within DroneZ in hardware, and this is done through the Vertex Programs of the nFiniteFX engine.

If you run a DX8 benchmark on a GeForce 2 the system will EMULATE the nFiniteFX engine in software for the very same reason: the GeForce 2 doesn’t support Vertex Shaders in hardware.

Emulation is never as good as native code. Just try running PS2 or N64 emulators on a PC you’ll see that I mean. 
Prior to the GeForce 3 (nFiniteFX), would write for a system with GeForce 2 + Pentium III or Athlon based platform. Traditionally, the coder would put all the possible stuff on the GeForce 2 hardware and do the rest on the main CPU with optimized code for the CPU itself (e.g. using SSE optimization).

Prior to the first GeForce video card, you couldn’t do T&L in hardware on previous boards, so, what did you do? Did you compare the GeForce hardware T&L with a GeForce emulator, or with other engines using software T&L?

When, in DroneZ benchmark, you run the “GeForce 2 Bump” and “GeForce 3 Bump” configurations you get exactly the same visuals, but with different implementation of the illumination system. In the first case it’s done with the combination of the video card and CPU (Pentium, or Athlon), which all programmers always did until now. In the second case it’s done through Vertex Programs that are executed in hardware if the nFiniteFX is present (GeForce 3); otherwise they are emulated by your main CPU! Indeed the DX8 drivers and OpenGL drivers include an nFiniteFX emulator to perform Vertex Shaders/Programs emulation.
Then, what happens if you try and run the “GeForce 3 Bump” configuration on the GeForce 2 system? The same thing that happens when you run any DX8-benchmark: The nFiniteFX will be emulated! The visuals will be the same, but the speed will be much slower!

So, on a GeForce 2, we will run:

The difference in frame rate between “GeForce 3 Bump” and “GeForce 2 Bump” on a GeForce 2 system is the overhead of the emulation. As you can see it would not be a fair comparison to do the test using nFiniteFX software emulator: it’s the CPU to handle the code in both cases only that in the first case its optimized code and in the second case its (slower) emulation code! This is not because the emulation code is flawed, it’s just because it’s an emulation of something else: something else that your CPU is not!
On the other hand, on a GeForce 3 we will also run:

About resolution

if you run the benchmarks at hi-res, like 1600×1200, you are fillrate-bound: this means that you are using most of the time drawing pixels rather than performing geometric calculations. This is interesting, but it’s not a really good test to measure the actual power of the nFiniteFX engine: in fact, you would get more or less the same results as running a game that doesn’t use Vertex Programs, like Quake3.

The same issue occurs if you are running at a lower resolution, but you are using FSAA.
If you run the benchmarks at a lower resolution (e.g. 1024×768 without FSAA) you will be geometry-bound and you will clearly see how the nFiniteFX engine is powerful compared to any software implementation, even if it’s the best possible optimized code for PIII + GeForce 2.

Putting this logic to extreme consequences, if you run at a very low resolution you get an ideal measure of the power of the nFiniteFX engine compared to the GeForce 2 system by running:

At this resolution you can also run both configurations on the GeForce 2 and you will really understand how slower the emulation is when compared to the optimized, native CPU code. Again: the emulation is always executed on the CPU; you are just comparing emulation code to optimized code!

Eventually (running at low resolution) we saw how to:

• Compare old technology at its best to new technology at its best:
  Running “GeForce 3 Bump” on the GeForce 3 and “GeForce 2 Bump” on the GeForce 2
• Evaluate the advantage of the nFiniteFX engine vs. optimal code:
  Running “GeForce 3 Bump” and “GeForce 2 Bump” on the GeForce 3
• Evaluate the overhead of the emulation vs. optimal code:
  Running “GeForce 3 Bump” and “GeForce 2 Bump” on the GeForce 2

The “GeForce 3 Bump HQ” uses Texture Shaders, so it is not compatible with previous hardware.