3DMark®2001 contains a number of tests divided into different categories. There are game tests, theoretical tests, feature tests and image quality tests (image quality tests are available only in the Pro version of 3DMark2001).

Game Tests
The game tests give the actual 3DMark score, which is the standard measurement of PCs' 3D game performance. When running the game tests, 3DMark2001 keeps track of the frame rate and calculates an average frame rate after the test is run.

The 3DMark overall score is based on the four game tests only. For more information, see the benchmark results section.

The game tests are short runs of a number of different types of scenes that simulate future games. The game tests produce the same workload for your PC as real 3D games do, because they use a real 3D game engine. One of the game tests is made even more game-like by using real-time physics and artificial intelligence. With additional effort, all of these game tests could be made into full games. Still, when running short tests and measuring the performance, we don't need a huge 3D world to play through, a game scheme and a storyline, or any game controls. However, to prove to our users that all these tests can be made into a game, we have added a game demo, where one of the game tests is equipped with game controls.

Theoretical and Feature Tests
Traditionally benchmarks in our 3DMark series have also included a number of theoretical tests, designed to measure the performance of some particular quality of your PC's graphics hardware. 3DMark2001 also includes these and we have concentrated on the most essential performance qualities of 3D hardware: fill rate and polygon throughput. Additionally, there are some feature tests. Firstly, there are bump mapping tests demonstrating environment bump mapping and Dot product 3 bump mapping (DOT3). Then there are what we call DirectX®8 (DX8) feature tests. These show new features in DX8, which are demonstrated for people curious about the differences between DX8 and earlier versions. They are also a good way for people with DX8 graphics hardware to confirm that the hardware does what it should. The tests do measure frame rate, which shows the difference in speed between hardware acceleration and software emulation. These frame rate results can also be used for comparing performance between DX8 graphics hardware, but our main goal when developing these tests was to demonstrate these new DX8 features.



Game Tests

Game Test 1 - Car Chase
It's a futuristic scene with hostile robots attacking Earth. The insurgence has been going on for some time, as witnessed by the destroyed houses and trashed cars littering the post-apocalyptic landscape. But it isn't over! A small group of people are still fighting back, standing their ground with a battle-weary pick-up trucks armed with homing missiles.In addition to the flying robots, there is a huge walker, scanning the horizon with searchlights and shooting at anything that moves. The trucks swerve to evade enemy fire and bravely shoot back.

This game test uses Ipion real-time physics by Havok (www.havok.com) for the truck movements, which means that tire friction during acceleration, breaking and skidding looks and feels right. Also the car suspension works with the real-time physics. The hostile flying robots use artificial intelligence when chasing and firing at the car. All of this means that this game test is more game-like than any game test in the 3DMark series.

The high detail scene has the following additions compared to the low detail scene:

Technical details:

Low detail statistics:

High detail statistics:

NOTE: The compressed textures are of four times higher resolution than the 16 and 32 bit textures. This clearly demonstrates the advantage of compressed textures

Game Test 2 - Dragothic
A dragon and a mysterious rider attack a village and bombards it with fireballs. The panicked citizens flee the buildings and attempt to run from the village in horror! Soldiers defend the village by firing burning arrows at the dragon.

This game test uses a new Global Illumination (GI) system, Lumigraph by Remedy Entertainment (www.remedy.fi) and Hybrid (www.hybrid.fi). Traditionally 3D games with a GI system have had a base texture, also called color texture, and a multiplicative light map. The multiplicative light map is the one that makes the corners of a room look darker than those parts, which are directly under a light source. This new GI system has an additional texture layer, an additive light map. The additive light map is for making surfaces directly under a light brighter than the color texture by itself. The animations of the dragon, the bowmen and the running people are done by morphing, using a vertex shader.

The high detail scene has the following additions compared to the low detail scene:

Technical details:

Low detail statistics:

High detail statistics:

Game Test 3 - Lobby
A man walks into the lobby of a building and meets heavy resistance. Multiple "bad guys" armed with various weapons start shooting at the man, who shoots back, and together they wreck the lobby pretty badly.

This test is full of impressive characters, their textures, guns and animations. All of these are the property of Remedy Entertainment from their upcoming game, Max Payne. The lobby, the cameras, shadows, reflections and everything else was created by the 3DMark team of MadOnion.com. This scene was originally made to be only a part of the demo, but it is indeed very game-like, so we decided to make it also a game test. Don't forget to watch the demo with the whole story.

All the characters use vertex shader skinning except if your system has a DirectX7 generation 3D accelerator, capable of hardware transformation and lighting. Then skinning is done using a custom skinning technique, which does skinning on the CPU, but transforms and illuminates the skinned vertices in the graphics hardware. This technique is more efficient for such cards because a vertex shader implementation would transform and light the vertices using the CPU, which would most likely be slower. The empty shells and discarded guns are controlled by Ipion real-time physics by Havok.

NOTE: The scene is not from Remedy's game Max Payne, and should not be used to evaluate how Max Payne will look or play.

The high detail scene has the following additions compared to the low detail scene:

Technical details:

Low detail statistics:

High detail statistics:

Game test 4 - Nature
It's a beautiful nature scene, with the leaves on the trees and the grass swaying in the wind. There is a small river with a man fishing and a little lake with small waves from the wind.

This scene depends heavily on DirectX® 8 features. The trees, grass and butterflies are animated, transformed and lit using vertex shaders. The movements of the fisherman are made by morphing, also using a vertex shader. The surface of the lake uses vertex shaders, pixel shaders and cube maps. Due to the pixel shader use, this test cannot be run without DX8 compatible graphics hardware. The scene only has a high detail run and affects the 3DMark score accordingly.

Technical details:

High detail statistics:



Theoretical Tests

Fill Rate
These two tests measure the fill rate 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 small 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 fill 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 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 can draw 8 texture layers in a single pass, then there will be 8 objects with 8 texture layers each. 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.

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

Note: This test has changed since 3DMark2000 (to be more realistic). Therefore results are not compatible with 3DMark2001.

High Polygon Count
This test measures the polygon throughput of the graphics hardware. Like above also this quantity is partly measured also in the game tests, but here we try to concentrate on this quantity alone. Therefore, we draw a scene with only few textures, which would limit the performance according to the fill rate, but with a large number of polygons. There are over one million polygons in this scene. The polygon throughput decreases, when there are more hardware lights and also when there are shiny surfaces in the scene done using materials with a specular reflection. There are two test runs in this test:
  1. 1 light: For a high throughput, we have only diffuse materials and a single directional light in this run.
  2. 8 lights: We have the same scene, but the dragons are of a shiny material giving a specular reflection. There are 8 lights all in all; one directional and 7 point lights.

The test result is given in million triangles drawn per second (MTriangles/s).

 

Bump Mapping
In a way, this is a feature test. We want to show what bump mapping looks like, and we also want to prove to you that your hardware is or isn't capable of doing it. We do measure the frame rate, so this test can be used for comparing bump-mapping performance. Bump mapping can not be reasonably emulated in software on DirectX, so the tests are skipped if your hardware doesn't support these types of bump mapping. If your hardware supports one type of bump mapping and not the other, the one that is supported will be displayed and the other will be skipped. There are two different bump mapping techniques displayed:

1. Environment Mapped Bump Mapping. This technique was introduced in DirectX® 6, and has been included in 3DMark2000 as well. Still, only a few graphics cards support this type of bump mapping. It appears that this is about to change as the DirectX® 8 pixel shader feature includes the requirement to perform environment mapped bump mapping. What is so special about this type of bump mapping is that we can do reflective environment mapped surfaces, which are bumped at the same time.

2. Dot Product 3 Bump Mapping (DOT3). This method of bump mapping was introduced in DirectX® 7. It is a mathematically more correct way to do bump mapping compared to the method described above. The basic DOT3 can only be used on diffuse surfaces. There are ways to extend DOT3 to include a specular component, but only the basic DOT3 is demonstrated here.



DirectX 8 Feature Tests

These three tests demonstrate some of the new features of DirectX 8. The pixel shader test is skipped if the feature is not supported by your hardware. As with bump mapping, this feature can not reasonably be emulated in software. Both the Vertex Shader and the Point Sprite tests can be run even if your hardware does not support the features natively, but then they will be emulated on the CPU, making the result highly dependent on the CPU speed. All of these tests measure frame rate. The features demonstrated are the following:

Vertex Shader
Vertex shader is like DirectX® 7 hardware transformation and lighting, but with a vertex shader the developer can write a custom transformation and lighting model. While this test demonstrates a vertex shader that does skinning, vertex shaders can be used for countless other types of transformation and lighting too. There are 100 skinned characters from game test 3 running around and shooting each other. Vertex shaders can be efficiently emulated in software, therefore this test is run using a software vertex shader, if vertex shaders cannot be run in your graphics hardware.

Pixel Shader
Pixel shader is a technique for making custom per pixel lighting or other per pixel operations in a 3D scene. Bump mapping is a kind of per pixel operation, because it makes a surface look bumpy due to modifications of the pixel colors, without touching the scene geometry, or in other words the polygons of the scene. This test demonstrates a water surface drawn using a pixel shader. This test requires DirectX 8 compatible hardware.

Point Sprites
Point sprites are a kind of particles which have more limitations than custom particle systems, but are drawn very fast if there is hardware support for them. There are about 500000 particles simultaneously on-screen in this test and they are used for rendering a 3D model. Particles are usually used in games for effects like fire, smoke and explosions. We are using such a large number of particles that we have to use particles the size of a single pixel. If we didn't, the test would become heavily fill rate limited.



Image Quality

This test takes a sample screenshot from each game test for closer inspection using ResultBrowser2001 (RB2001). Our RB2001 allows you to compare your card's rendering to reference images rendered using the Direct3D reference rasterizer. RB2001 contains tools for zooming and making per pixel comparisons with the reference images or with renderings of other graphics hardware. This test is only available in the Pro version of 3DMark2001.



Test Methodology

All tests (except for the image quality tests) measure the average framerate (rendered frames / second), like described in the list below. Some tests give a result of a different unit (Fill rate test: million texels / second), but even in these tests the frame rate is measured before the result is converted to the given unit.

All performance tests are run the following way:

  1. Initialize the scene
  2. Render 1-3 (depending on the test) frames for "warm-up", to download necessary textures to the texture memory of the graphics card.
  3. Start the timer
  4. Render as many frames as possible within n seconds
  5. When n seconds is reached, draw a black triangle after all the frames in the pipeline, to ensure that all frames have been displayed
  6. Lock the frame buffer
  7. Stop the timer
  8. Unlock the frame buffer
  9. Calculate the result based on "NumberOfFramesRendered / Time"
  10. De-initialize the scene