BFG
Technologies ASYLUM GeForce FX 5700 Ultra Review - Page 5 Of 9
By Clay Angelly - October 23, 2003
3DMARK 2003 (patch 330)
I still maintain that actual game benchmarks are more
useful and representative of a cards real-world performance. However, balance is
always a good thing and synthetic benchmarks can play a supporting role if used
properly along with actual games. Having said that, the scores for 3DMark 2003
(patch 330) are shown below.
NOTE: The benchmark was run at all default settings
and at 1024x768 resolution.
3DMark 2003 Scores
*
This was at default clocks (475/900) as 3DMark03 would
end prematurely with an error message if the 5700 was overclocked to 545/950.
HUMUS DEMOS
For those of you who may have skipped the introduction of this review you
may be looking at this and saying to yourself "Hum-whaaaat?" :) If so,
please jump back and read the introduction section
before proceeding.
First come the OpenGL demos. Again, all of these demos were benchmarked using
FRAPS 2.0. You'll notice Humus' own FPS counter in the upper left of each
screenshot below. I can confirm that his FPS counter matched that of what FRAPS
was reporting. Since this is not an established/widely accepted form of
benchmarking I did not test at multiple resolutions nor did I use FSAA or AF
during any tests. I'm playing a bit of "the guinea pig" role here after all. :)
Following are the settings used for each benchmark:
Screen Resolution: 1600x1200 (some demos do not allow
you to select the resolution but they appeared to run at the Windows desktop
resolution settings in which case those would be at 1024x768).
32-bit color depth
No FSAA
No AF
Duration of each test was 20 seconds
Also, I've received permission from Humus to reprint his
direct commentary for each demo here so as to provide you with all the
background/technical information in one location along with the results.
OpenGL Demos
ShadowsThatDontSuck - OpenGL
When I was at my job interview with nVidia we spoke a little about what kind of
project I'd do. As shadows are one of the hardest problems in 3d graphics and
most shadowing implementations has some kind of serious drawbacks I got the
suggestion to work on "shadows that don't suck" for a project. Even though I
didn't get the job I decided to try finding a good shadow algorithm myself
anyway. However, after being held back by a driver bug I left the project for
the time being and only recently got back into the project again.
What I have done is a shadow mapping implementation that works for point lights.
The idea is quite simple, instead of rendering the depth into a texture as with
normal shadow mapping I render the radial distance into a cubemap. The radial
distance is easy to look up in a 3d texture. A check with the stored distance
and the currently calculated distance is done in a fragment shader and can
easily interact with perpixel lighting. The final result is a very realistic
shadow effect.
One of my better demos IMO.
This is also the
first demo based on my new and much improved framework.
Thanks to MZ for the help with the register combiner code.
It will run on Radeon 8500/GF3 and up.
Required OpenGL extensions:
GL_ATI_fragment_shader or GL_NV_register_combiners
WGL_ARB_render_texture
GL_ARB_texture_cube_map
GL_EXT_texture3D
GL_EXT_texture_edge_clamp
Recommended OpenGL extensions:
GL_ARB_texture_compression
GL_EXT_texture_compression_s3tc
ShadowsThatDontSuck Benchmark Results
StencilShadows - OpenGL
This demo shows dynamic per-pixel lighting with shadows and
proper shadow overlapping. The shadows are created by using the stencil buffer
and Carmacks reversed algoritm.
Required OpenGL extensions:
GL_ARB_multitexture
GL_EXT_texture_env_dot3
GL_ARB_texture_env_combine
GL_EXT_texture_edge_clamp
GL_EXT_texture3D
GL_ARB_texture_env_crossbar or GL_NV_texture_env_combine4
StencilShadows Benchmark Results
Game Engine (OpenGL BSP) - OpenGL
A demo of the game engine I've been working on. It should run on the whole
Radeon series card, Parhelia, GeForce 3 and GeForce 4.
It's a flyby demo, moving you around in a not too unfamilar environment for some
of you FPS freaks out there.
More info about this engine can be found
here.
2002-05-04:
Bumping this demo up again as I've finally got around to clean up the code and
sort of finalized it. Source in now available for all you people that I know
have been waiting, I apologize for all the delay. There aren't a whole lot of
changes since last time, slightly tweaked lighting, the fogging I worked didn't
make it into the demo either, it would be too much trouble to get a solid
implementation on todays hardware with the method I tried.
Required OpenGL extensions:
GL_ARB_multitexture
GL_ARB_texture_env_dot3
GL_ARB_texture_env_combine
GL_EXT_texture_edge_clamp
GL_EXT_texture3D
GL_ARB_texture_env_crossbar or GL_NV_texture_env_combine4
Recommended OpenGL extensions:
GL_ATI_fragment_shader or GL_NV_register_combiners
GL_ARB_texture_cube_map
GL_ARB_texture_compression
GL_EXT_texture_compression_s3tc
Game Engine (OpenGL BSP) Benchmark Results
Direct3D Demos
PhongIllumination - Direct3D
This is another phong lighting with shadows demo. The difference compared to
earlier work is that this one uses Direct3D, R32F shadow cubemaps are used, the
squared distance is stored in the shadow map and a multiplication factor is used
instead of bias for a nice speedup.
This is the illustrating code for the "Fragment level Phong illumination"
article available in the new
Articles
section.
Required Direct3D capabilities:
Pixel shader v2.0
Vertex shader v2.0
R32F cube render targets
PhongIllumination Benchmark Results
SelfShadowBump - Direct3D
This demo does self shadowing bumpmapping. Letting the bumps in the bumpmap cast
shadows over the surface really adds a lot to the feeling of depth of bumpmaps.
On the bad side of things is that it's not exactly for free, though not horribly
expensive either. A horizon map is needed for every texture. The horizon map is
a 3D texture of considerable size. For some textures you can get away with a
fairly low res horizon map, for others you need a quite large one to get good
results. For this demo I'm using one 256KB large horizon map and one 1MB large
one for another texture. Performance quickly suffers if I use larger horizon
maps.
For the sky I've written a shader that animates some kind of cloudy
Quake-looking sky by using a 3D noise.
All shaders are written in HLSL.
The demo should run on Radeon 9500 and up and GeForce FX series.
2003-10-11:
Updated to include a menu item to let you toggle selfshadowing on and off.
Required Direct3D capabilities:
Pixel shader version 2.0
Vertex shader version 2.0
SelfShadowBump Benchmark Results
TransparentShadowMapping - Direct3D
Normally shadowmapping uses only a single channel of the texture the scene is
rendered to. Using that depth you can extract information about whether the
current fragment is in shadow or not. However, this only works for opaque
occluders. This demo extends the idea to work for transparent surfaces too, and
makes transparent surfaces cast a projection of itself over the scene. To do
this not only the depth is rendered to the texture, but also a color. Opaque
surfaces renders white along with the depth, while transparent surface renders
its color and leaves the depth unmodified. Then by simply multiplying the shadow
factor contructed in a normal shadowmapping fashion with the color stored in the
shadow map you'll get a nice projection of transparent surfaces over the scene.
The demo should works on Radeon 9500 and up and the GeForce FX.
Required Direct3D capabilities:
Pixel shader 2.0
Vertex shader 2.0
TransparentShadowMapping Benchmark Results
Sketch - Direct3D
This is a demo that renders the scene to look as if it would have been sketched.
This is done by finding edges in the picture. First the scene is rendered to a
texture and the normals and the depth are outputted into it. Then a Sobel filter
is applied to all components. This will highlight all edges, not only the
silhouette against the background, but also internal edges where there's a
difference in depth or when the normal changes a lot over a small distance. To
get a smoother image, and to give it a fuzzy pencil drawn feeling, the edge
value isn't thresholded, but instead I'm outputting the square of the Sobel
filter to allow all kinds of shades of gray. Finally a slight blur filter is
applied to smooth it out a little.
Should run on Radeon 9500+ and GFFX.
Required Direct3D capabilities:
Vertex shader 1.1
Pixel shader 2.0
Sketch Benchmark Results
So, what to conclude from these results...to be perfectly honest I have no
idea. That shouldn't be much of a surprise either since these demos don't have a
history of being benchmarked (to the best of my knowledge). I've requested that
Humus provide some insight on these results though and if he does I will update
this section of the review with that information.
My SWAG on these results is that the BFG 5700 Ultra held its own for the most
part regarding OpenGL performance. The large discrepancy in the Direct3D demos
is a more difficult call and one I'll wait on making until I know more. At any
rate, these are not representative of game performance and hopefully Humus (or
others) can shed some light on things in the near future.
