And your last sentance is also agreeing with me. Youre saying that PC have a restriction due to DX software and Cell does not. Hence the reason that Cell can do DX10 like effects.
It's not Cell! It's the
whole system. You need to understand the idea of a software abstraction layer. On a PC you can have all sorts of different chips in it. The only ways to make games run on all those different builds of PCs are either 1) Write 2000 different versions of your game to cater to all the different hardware combinations (actually way more than 2000!), or 2) Use a software abstraction layer. This allows developers to write general code, and the hardware manufacturers provide translation software (drivers) which turn that general code into specific instructions for each chip in the PC.
A very simple example : To draw a circle on the screen, for GPU 1 you might write something like -
Code:
SetPoint 400,300
SetRadius 50,50
DrawCircle
And for GPU 2 you might write
Code:
Do
x = 400 + sin(angle)*50
y = 300 + cos(angle)*50
DrawPoint x,y
angle = angle + 1
Repeat until angle = 360
These are not at all indicative of GPU programming, but they illustrate the point! If your game draws a circle on the screen, you'll need to include both bits of code in your game and choose the right one for the GPU the player has. The two are totally incompatible otherwise. Now if you add a software abstraction layer, the developer can write :
Code:
DX_DrawCircle(400,300,50,50)
GPU 1's driver translates that into its code and executes that on the GPU. GPU 2's driver takes exactly the same DX instruction but translates it differently, so GPU 2 can understand it and draw a circle exactly the same.
The benefit of DirectX is a standard interface for writing to the hardware that works for all the different GPUs etc. as long as the drivers are there (ha ha ha! Well, in theory...). The downside is that it limits you to what you can do on the hardware. Imagine GPU 2 has another feature where it can change the colour of the point drawn...
Code:
Do
x = 400 + sin(angle)*50
y = 300 + cos(angle)*50
[B] ChangeColour (random colour)[/B]
DrawPoint x,y
angle = angle + 1
Repeat until angle = 360
In this GPU code, the circle is randomized in the colours that draw it. However, using the (imaginary) DX command
DX_DrawCircle, this doesn't include the instruction to change the colour. Using DX thus prevents the developer from using the complete features of the GPU.
This is the key point!
The API makes things easier for developers, but also adds limits. GPU's are sold on the level of hardware acceleration they provide for certain features that DirectX implements. eg. You can use pixel shaders in DirectX, but limited to a certain number of instructions. If DX has a limit of 256 instructions for a pixel shader, and your GPU actually has a limit of 65,536 instructions, DX will prevent you using the GPU to it's full capacity. If you don't use DirectX, you can use a pixel shader of length up to 65,536 as the GPU supports.
This isn't an option for PCs. They
need an interface layer because all the hardware differs. GPU manufacturers thus target DirectX standards when the promote their hardware. This GPU is DirectX 9 compatible, or SM3.0, or DX10. These are rough bands though, and don't give an exact description of what the hardware is capable of. A part can be called DX9 for example, yet run some parts of DX9 too slowly to be any use. When you take a part and plug it into a closed box, where the devs don't need to use an abstraction layer, these rough bands mean even less. Xenos is a great example of this. In the PC space it would be called a DirectX 9 part because it doesn't feature all the needed DX10 bits to be DX10. But it has more features than a DX9 GPU. The end result is people trying to call it a DX9.5 or such GPU. This is a nonsense! DX is a software interface, not a GPU technical specification! There's no such thing as DirectX 9.5! That's like saying a boxer of 71 kg comes between welterweight (68 kg) and middleweight (74kg) so he weighs welterweight-and-a-half! The way you'd actually class this boxer's weight is 'he weighs 71 kg'. The way you'd class a GPU properly is 'it has these features', but of course those features are long and complicated and will confuse people anyhow, so the graphics cards sell them in the broad band of DX
n.
Even more importantly, you can use the hardware in the closed box however you want. You know
exactly what chips you have, and can write code for them, and time how long it takes to do stuff, and pass data between them. If you have the above GPU2 in there, you can write the code for it that uses the colour changing function, without limiting yourself to the DirectX instruction. If you have a sound processor that can take a sample input, apply an effect, and output it back into memory, you could if you chose feed it with some texture data, have it process the data as though it were a sample, and take the resultant output and use that a texture. On the PC you probably couldn't do that because the software abstraction doesn't allow it, and even if you can the system isn't setup up for nicely sharing data between processors. On a PC where a DirectX9 GPU like RSX doesn't have geometry shaders, a DX10game that includes them won't have any effect. In the closed box console the developer can implement geometry shaders themselves using the CPU in combination with the GPU (or whatever other processors are to hand). A DirectX 9 GPU is in the PS3 doesn't limit the whole system to only DirectX 9 capabilities, because DirectX 9 is a
software limit of the DirectX
PC hardware interface that only has relevance on the PC. For this reason, consoles cannot be considered as DirectX
n parts. You can't call RSX DX9 and Cell DX10+. They don't run DirectX! You can categorize RSX as a DirectX 9
level GPU, as that describes certain hardware features. But that doesn't describe the limits of the box. The oft used and most apt example of DirectX's irrelevance in gaming is the PS2. It doesn't run DirectX, and hasn't got a DirectX compatible GPU. Yet the
system manages to do lots of things that DirectX compatible GPUs on PCs could do. PS2 doesn't not support any shader model, yet can execute pixel and vertex shader effects.
This is why it's bad practice to refer to consoles with DX part numbers and references. What you really mean to say is 'Where a DirectX 10 GPU supports features x,y,z in hardware, and RSX doesn't support these features, Cell is in a position to implement these features.' From that position you can then debate Cell's efficacy in these features, without referring to a broad and somewhat meaningless metric. You need to talk specifically in hardware features that are independent of the software interfaces, because in a console a developer can write without recourse to software layers at all if they're feeling crazy enough!
