3DMark03 features a series of tests that have different functions within 3DMark. The Game Tests are used to produce the 3DMark score and the Feature Tests are used to highlight specific functions of your system, such as shader speed or fill rate.

Previous 3DMarks have all used MAX-FX as 3D engine. The DirectX 8 introduction of vertex and pixel shaders made such massive middleware needless in 3D games for hardware with full support for DX8 or later. Therefore 3DMark03 is basically directly written onto DirectX. A small library of helper functions is used in order to avoid unnecessary rewriting of code for each test. All vertex processing is handled by vertex shaders and all pixel processing (except game test 1 and the fill rate tests) is done with pixel shaders. This makes 3DMark03 a very forward looking benchmark, and it might scale somewhat differently than many games at launch time, which still mainly rely on fixed function vertex and pixel processing. Then again, the mission of 3DMark is to give an insight into the next generation of 3D games and their performance requirements. Some information of the technology of the next generation of 3D games was available during the development of 3DMark03, but as usual, different types of games use different optimizations, and reflecting an average of all that in advance is next to impossible. 3DMark03 therefore measures above all DirectX vertex and pixel shader performance, since this is our best estimate of next generation 3D game technology and performance requirements.


Game Tests

There are 4 game tests - each one is designed to represent a certain type of 3D game, and thereby offer a wider range of 3D game workloads. 3DMark03 records the total number of frames rendered. Using the length of time for the test, an average frame rate is produced. A higher average framerate is better. The results from the four game tests are then collated to produce the total 3DMark score.

The 3DMark total score is calculated using the following formula:

3DMark score = (GT1fps * 7.3) + (GT2fps * 37) + (GT3fps * 47.1) + (GT4fps * 38.7)

GT1fps means the average frame rate measured in game test 1.


Game Test 1 - Wings of Fury (DX7)

It is 1944 and an allied bomber squadron is approaching its target, deep in enemy territory. Courage and determination is displayed by both sides in this conflict, as the bombers endure the relentless attacks of the flak cannons and fighters, who in turn, battle against the hail of bullets.

The style of this game test is a combat flight simulator, with additional cinematic shots. It also represents 3D games mainly written for slightly older hardware (DirectX 7 and upwards); the polygon count per frame is relatively low; a large part of the pixels on screen are on the single textured background objects; but there are plenty of particles.

Some technical details:


Game Test 2 - Battle of Proxycon (DX8)

A large spacecraft is the scene of an intense and heart-pounding battle. The attacking enemy board the craft using breach pods but are soon met by the brave defenders. The camera moves from the first-person view of the player to a cinematic view, capturing the excitement of the skirmish.

This style of game is clearly a FPS - first person shooter - and represents a modern game for modern hardware. All vertex and pixel processing is done using shaders, so a DirectX 8 compliant graphics adapter is required for this test. The awesome visuals demonstrate the power and flexibility that shaders offer.

Some technical details:


Game Test 3 - Trolls' Lair (DX8)

A brave adventurer enters an old study, her magical sword providing the only light. Everything looks normal until she discovers a hidden switch in the bookcase. Two rather large surprises await the warrior at the bottom of the steps!

Many 3D games use the "in-game" graphics engine for the cut scenes, which are used to emphasise parts of the story. This game test represents such a sequence and uses the same range of vertex and pixel processing as in game test 2.

Some technical details:


Game test 4 - Mother Nature (DX9)

More and more game designers are using vertex and pixel shaders to create scenes of amazing realism and beauty. 3DMark2001 first demonstrated some of the visual effects possible with shaders and now 3DMark03 returns to the natural world around us.

This game test represents the level of effects and realism that are possible using 2.0 vertex and pixel shaders, plus some of the other features that DirectX 9 offers.

Technical details:

 


CPU Test

3DMark03 is highly dependent on graphics card vertex and pixel shader performance. The CPU speed influences less the total 3DMark score, and therefore there is a separate CPU test. The CPU test measures above all DirectX software vertex shader performance. The result is somewhat influenced by the graphics card's pixel shader performance. Therefore a CPU performance comparison should be run using the same graphics card, graphics drivers and operating system on all systems compared.

CPU test details:

Note: Neither CPU test will not run if the graphics hardware does not support 1.1 pixel shaders.

The CPU score is calculated using the following formula:

3DMark score = (CPU1fps * 4.6) + (CPU2fps * 27.5)

CPU1fps means the average frame rate measured in CPU test 1.


Feature Tests

Feature test - Fill Rate

These two tests measure the fill rate speed of your graphics hardware. Fill rate is a measurement of how fast the graphics card is capable of drawing textures onto 3D objects. The results of the game tests are naturally dependent on the fill rate, but in this test we try to concentrate on measuring only fill rate. We do this by drawing a number of large surfaces perpendicular to the viewer that cover the whole screen and fill these objects with large textures. There are two different test runs included in the fill rate test, and they are:

  1. Single-Texturing: There are 64 surfaces with one texture each. This means that the graphics hardware fills each of these objects separately, no matter how many texture layers that card is capable of drawing in a single pass.
  2. Multi-Texturing: We draw 64 texture layers as fast as possible. This means that we take advantage of the fact that modern cards are usually capable of drawing multiple texture layers on a single object nearly as fast as it would draw one single layer. 64 texture layers are distributed so that each surface in use has as many texture layers as that particular card can draw in a single pass. For example, if your card is capable of doing 6 texture layers in a pass, there will be 10 objects with 6 layers and an 11th layer with the remaining 4 layers. Fixed function texturing has an upper limit of 8 textures per pass, which means that even modern DX9 hardware capable of up to 16 per pass, will not do more than 8.

The test result is given in million texels (texture elements, pixels in the source texture) drawn per second (MTexels/s). Higher results are better.

Note: This test has changed since 3DMark2001. Therefore results are not compatible with 3DMark2001 SE or the original 3DMark2001.

 

Feature test - Vertex Shader speed

Pack a room full of angry trolls and what do you get? Lots of fighting! In this feature test, 30 troll characters run around bashing each other with clubs - each one is constructed from over 5500 polygons with vertex shaders being used to skin them. The troll texture layers are produced using 1.1 pixel shaders in four passes, using bump and cube maps. Therefore, each troll is skinned four times, raising the number of skinned polygons to over 700000.

The average framerate is given as result (fps).

Note: this feature test will be skipped if there is no hardware support for 1.1 pixel shaders.

 

Feature test - Ragtroll

Several trolls plummet to the ground. High level physics modelling from Havok is applied as the characters tumble and bounce about. This test offers a heavy load for both the graphics card and the CPU, as sixteen ~5500 polygon trolls are vertex shader skinned and are affected by rag doll physics. This test is excellent for demonstrating the advantage of hardware accelerated vertex shaders. In 3D games the CPU is normally quite occupied with physics, artificial intelligence and other game play tasks. Offloading vertex processing from the CPU therefore accelerates the overall game play performance. Since the CPU is heavily loaded with real time physics, efficient hardware vertex shader support should improve the test result significantly. You can see the difference by running this test using forced software vertex shaders for comparison. The test uses the same lighting model as game tests 2. Please read the details about it in the chapter describing game test 2.

The trolls do collide with objects in the surrounding, but do not collide with eachother. A different kind of test would have been required to include that functionality.

The result from this test is shown as the average number of frames per second (fps).

Note: this feature test will be skipped if there is no hardware support for 1.1 pixel shaders.

 

Feature Test - Pixel Shader 2.0 test

Procedural volumetric texture maps, simulating wood and marble, are generated using 2.0 pixel shaders.

a) The marble pattern that is applied to the elephant and rhino is produced procedurally in real-time using a 3D turbulence texture map. Pixel shaders are used to sample this map and then apply the following mathematical function to adjust the final colour of each pixel:

Colour = lerp(DarkMarble, LightMarble, sin((turbulence(position+frequency)+position.x*scale)*Pi)

b) The plate is generated using a procedural wood texture. Pixel shaders are used to sample a noise map several times and then produce the turbulence values; these are employed in the mathematical function used to adjust the pixel colour:

Colour = smoothpulsetrain(lightwood,darkwood,turbulence(ring_offset))

This function accounts for the fact a slice of wood has different colour layers due to tree rings, which also vary in frequency and width. Each test result is shown as the average number of frames per second (fps).

Note: the feature test will be skipped if there is no hardware support for 2.0 pixel shaders.

 

Feature test - 3D Sound Test
3DMark03 features an exciting new addition - a benchmark of your PC performance when running a 3D scene with multiple 3D sound sources. Game test 1 is processed over 3 runs. First with no sound sources at all (as a reference point), then with 24 sound sources and finally with 60 sources. Each source is accurately modelled to incorporate 3-dimensional positioning, Doppler effects, and attenuation. This test uses the FMOD music and sound effects system.

The test result is shown as the average number of frames per second (fps). The interesting measurement in this test is the difference between the reference run without sounds, and the 24 and 60 sound runs. A smaller difference in frames per second is better.

Note: a sound test run will be skipped if there is no hardware support for the amount of 3D sound sources required.