maximus wrote:Maybe ATI had already done this voluntarily with the R300 architecture, but everything I've seen indicates that the change officially happened with DirectX 10:
"Direct3D10 finally completes the break from the legacy fixed-function pipeline. Developers will use the programmable pipeline to emulate the older, fixed-function steps." (source)
"Direct3D 10 no longer supports the fixed-function transform and lighting pipeline." (source)
They are talking about the API-side, not the hardware-side.
maximus wrote:Maybe this is the difference: DirectX 9 hardware must support the fixed function pipeline, though not necessarily in hardware. DirectX 10 hardware is only required to support DirectX 10, and DirectX 9 emulation is done entirely in software as a courtesy.
Well, almost.
Yes, DirectX 9 drivers (not hardware) have to support the fixed function pipeline. This is because DirectX 9 has support for legacy hardware/drivers as well. I have an overview on my blog: https://scalibq.wordpress.com/2012/12/07/dire … -compatibility/
As you can see, DirectX 9 requires a DDI7-driver. Which means that any DirectX 7-class or higher hardware is supported by the API. Since programmable shaders weren't introduced until DirectX 8, this implies that DirectX 9 must support fixed function as well.
But it is up to the driver how this is implemented.
DirectX 10 has no fixed function pipeline in the API anymore, and therefore your hardware MUST support shaders (and they made the requirement SM4.0 as well, so you have to have full DX10-compliant hardware). Even if your hardware had a fixed-function pipeline on board, you can't use it via DirectX 10. But by the time DX10 was introduced, all vendors had long replaced their fixed-function pipelines with shaders anyway.
The funny thing as you can see is that DX11 requires only a DDI9 driver, and as such it can run on DX9-class hardware with SM2.0. This is mainly for Windows Phone support, where most SoCs don't support DX10+ level yet.
Each DirectX version is a standalone API (unlike OpenGL, where there is a single API with different versions). So DirectX 10 does not have anything to do with DirectX 9 whatsoever.
DirectX 9 and earlier APIs all live together, each interface in their own COM-like objects.
"DirectX 9 emulation" is not the right term if you ask me. DirectX does not specify how hardware should implement functionality, and there are often huge differences between hardware from different vendors and/or generations.
You are not 'emulating' anything, you are implementing a spec. So you can't say that there is "one true implementation" and that any other implementation is an "emulation" of the real implementation.
It's also not done "entirely in software", since that would imply software-rendering, which would be far too slow. It's just that older APIs had fixed-function processing, which is now pre-programmed by the driver on programmable hardware. It's still done in hardware, and it's often actually faster than a fixed-function solution, since it is more flexible.
I think it is similar to the x86 instructionset. To be x86-compatible, you need to implement the instructionset. But it doesn't matter HOW you implement it. There have been dozens of different x86 implementations over the years, but you wouldn't call them 'emulators of the 8086', let alone that they 'emulate in software'.