Page 4
The slow move to DirectX 10
Despite the fact that graphics cards are all about programmability and thus shaders these days, you'll notice in today's product that we'll not be talking about pixel and vertex shaders much anymore. With the move to DirectX 10 we now have a new technology called Unified shader technology, and graphics hardware will adapt to that model, it's actually very promising.
DirectX 10 has been shipping since the first public release version of Windows Vista, which is also its biggest downside; you need to have Windows Vista. It will definitely change the way software developers make games for Windows and very likely benefit us gamers in terms of better gaming visuals and better overall performance.
So what's this shader thingy all about?
If you recently attempted to purchase a video card, then you will no doubt have heard the terms "Vertex Shader" and "Pixel Shader" and with the new DirectX 10 "Geometry Shaders". Let's do a quick course on what is happening inside your graphics card for to be able to poop out all these millions of pixels that are assigned a color value.
What do we need to render a three dimensional object as 2D on your monitor? We start off by building some sort of structure that has a surface, that surface is built from triangles. Why triangles? They are quick to calculate. How's each triangle being processed? Each triangle has to be transformed according to its relative position and orientation to the viewer. Each of the three vertices that the triangle is made up of is transformed to its proper view space position. The next step is to light the triangle by taking the transformed vertices and applying a lighting calculation for every light defined in the scene. And lastly the triangle needs to be projected to the screen in order to rasterize it. During rasterization the triangle will be shaded and textured.
Graphic processors like the GeForce series are able to perform a very large amount of these tasks. The first generation was able to draw shaded and textured triangles in hardware. The CPU still had the burden to feed the graphics processor with transformed and lit vertices, triangle gradients for shading and texturing, etc. Integrating the triangle setup into the chip logic was the next step and finally even transformation and lighting (TnL) was possible in hardware, reducing the CPU load considerably. The big disadvantage was that a game programmer had no direct (i.e. program driven) control over transformation, lighting and pixel rendering because all the calculation models were fixed on the chip.
And now, we finally get to the stage where we can explain shaders as that's when they got introduced.
A shader is basically nothing more than a relatively small program executed on the graphics processor to control either vertex, pixel or geometry processing and it has become intensely important in today's visual gaming experience.
Vertex and Pixel shaders allow developers to code customized transformation and lighting calculations as well as pixel coloring or all new geometry functionality on the fly, (post)processed in the GPU. With last-gen DirectX 9 cards there were separated dedicated core-logic in the CPU for pixel and vertex code execution, thus dedicated Pixel shader processors and dedicated Vertex processors. With DirectX 10 something significantly changed though. Not only were Geometry shaders introduced, but the entire core logic changed to a unified shader architecture that is a more efficient approach to allow any kind of shader in any of the stream processors.
ATi's HD 2900 XT has 320 stream processors, the 2600 120 and the 240 40 stream processors.
So what is a vertext or pixel shader? It's a small piece of code that is executed on the Stream (Shader) processors inside your GPU, which returns it's results:
| Example of a Pixel Shader instruction | Example of a Vertex Shader instruction |
| #include "common.h" struct v2p { float2 tc0 : TEXCOORD0; // base half4 c : COLOR0; // diffuse }; // Pixel half4 main ( v2p I ) : COLOR { return I.c*tex2D (s_base,I.tc0); } |
#include "common.h" struct vv { float4 P : POSITION; float2 tc : TEXCOORD0; float4 c : COLOR0; }; struct vf { float4 hpos : POSITION; float2 tc : TEXCOORD0; float4 c : COLOR0; }; vf main (vv v) { vf o; o.hpos = mul (m_WVP, v.P); // xform, input in world coords o.tc = v.tc; // copy tc o.c = v.c; // copy color return o; } |
Now, this code itself is not at all interesting and I understand it means absolutely nothing to you, but I just wanted to show you in some sort of generic, easy to understand manner (Ed: Ooooh... o.hpos = mul (m_WVP, v.P)... it all makes sense now, Hilbert :P) what a shader is and involves.
Now we can go back to the review as you'll understand DirectX 10 a little better.
