![]()
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 TestsThere 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:
- All vertex processing is done using 1.1 vertex shaders - these are processed by either the graphics adapter or the CPU, depending on the hardware support.
- All the planes have 4 texture layers - one color texture, two fixed cube maps for lighting and reflections, plus one gloss map. Graphics adapters capable of applying 4 texture layers per pass will only require a single pass to texture each plane.
- Particles are used a lot in this test - smoke and vapour trails, flak and gunfire, and explosions are produced using point sprites and quads. Most particles are DirectX accelerated point sprites, but due to their limitations, normal quad particles are also used for some effects.
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:
- All vertex processing is done using 1.1 vertex shaders - these are processed by either the graphics adapter or the CPU, depending on the hardware support.
- All character models are skinned using vertex shaders.
- Some light sources generate dynamic shadows using the stencil buffer.
- All pixel processing is done using 1.1 pixel shaders or, where supported, 1.4 pixel shaders.
- The spaceship interior and character models have texture materials consisting of a base layer, a reflectivity map, a normal map.
- Lighting is calculated per pixel for specular and diffuse components.
- 1.1 pixel shader hardware use one rendering pass for depth buffer setup and then 3 passes per light source affecting the object to be rendered.
- 1.4 pixel shader hardware use one pass for depth buffer setup and a single pass per light source affecting the object to be rendered.
- Havok real-time physics modelling is used for crashing and falling animations.
- The demo part of game test 2 uses post-processing effects, such as Depth of Field and Bloom effects, using 1.1 pixel shaders. These effects can also be enabled for the benchmark run.
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:
- All vertex processing is done using 1.1 vertex shaders - these are processed by either the graphics adapter or the CPU, depending on the hardware support.
- All character models are skinned using vertex shaders.
- Some light sources generate a dynamic shadows using the stencil buffer.
- All pixel processing is done using 1.1 pixel shaders or, where supported, 1.4 pixel shaders. The lighting model is the same as in game test 2. Please read the details above.
- Havok real-time physics modelling is used in explosions, plus crashing and falling animations.
- A custom physics model is used for the main character's hair - each strand has force calculations applied to every vertex. The hair is anisotropically lit.
- The demo part of game test 3 uses post-processing effects, such as Depth of Field and Bloom effects, using 1.1 pixel shaders. These effects can also be enabled for the benchmark run.
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:
- Every leaf is separately animated using 2.0 vertex shaders. The grass in animated using 1.1 vertex shaders.
- The lake surface material is produced using 2.0 pixel shaders. The number of texture stages used is staggering - multiple reads from a normal map; a ripple map; reflection, transparency and refraction maps; a cubic environmental map, plus per-pixel Fresnel effects are applied.
- The sky is also rendered using 2.0 pixel shaders. The higher dynamic range of colour supported by DirectX 9 is used for the Sun. The same type of sky can be seen at the end credits of the demo on hardware supporting 2.0 pixel shaders.
- The ground material is produced using 1.4 pixel shaders; some of the texture stages include a detail map, a lightmap, a bump map and renormalisation cube map. In addition to this, a "cloud layer" is applied to produce the moving shadows the clouds make as they pass overhead.
CPU Test3DMark03 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:
- Game Tests 1 and 3.
- Forced software vertex shaders, because software vertex shader speed is what this test is designed to measure.
- 640 x 480 resolution, in order to minize the fill rate influence in the test result. If we would have selected an even smaller resolution, it might have been hard to see if everything really is rendered. Also, many TFT displays can't display smaller resolutions.
- Game Test 3 has the shadows disabled, because the dynamic stencil shadows are rather dependent on the fill rate of the graphics hardware, and that is an aspect we want to minimize in this test.
- Game Test 3 has also the 1.4 pixel shader code path disabled, because otherwise graphics hardware with pixel shader 1.4 support would get a higher score, and we do not want to credit that feature in this test.
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 TestsFeature 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:
- 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.
- 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.
![]()