The new configuration, the new Windows Vista, his DirectX 10 and her competitor

The Highly Anticipated DirectX 10

Windows Vista includes a major update to the Direct3D API. Originally called WGF 2.0 (Windows Graphics Foundation 2.0), DirectX 10 and DirectX Next, it features an updated shader model — the shaders still consist of fixed stages like on previous APIs, but all stages sport a nearly unified interface, as well as a unified access to resources. The language itself has been extended to be more expressive (integer operations, nearly unlimited instructions count). In addition to the previously available vertex and pixel shader stages, the API includes a geometry shader stage that breaks the old model of one vertex in/one vertex out, to allow for more complex effects in real time. Direct3D 10 no longer uses “capability bits” to indicate which features are active on the current hardware. Instead, it defines a minimum standard of hardware capabilities which must be supported for a display system to be “Direct3D 10 compatible”. Therefore, contrary to the previous revisions of Direct3D, it requires new graphics hardware to run at all, whereas prior versions allow the old hardware capabilities to be addressed within the new interface. This is one of the major departure of this new API, and it is justified by Microsoft as the only way to achieve the CPU efficiency gains needed for the newest pieces of hardware without the clutter of legacy code.

Many of the advanced features and performance improvements of Direct3D 10 mandate the use of WDDM-compliant drivers. WDDM drivers are also required by Direct3D9Ex, an extended version of DirectX 9.0c, used in Windows Vista. D3D9Ex was previously known as WGF 1.0 and D3D9.0L. However, D3D9Ex needs WGF 1.0 drivers (previously, basic profile), and D3D10 needs WDDM 2.x drivers (previously, Advanced profile) which supports the extended graphics pipeline. D3D9Ex features similar improvements like better gamma control, support for virtualization of resources and safe device removal, other improvements make D3D10 incompatible with previous versions.

Because Direct3D 10 hardware will be comparatively rare for a period of time after the release of Windows Vista, and because the Vista Premium logo program does not require Direct3D 10 to be supported, the first D3D10-compatible games will most likely still provide a D3D9/D3D9Ex render path.

Windows Vista and DirectX 10 from CNET News.

It’s been called DirectX 10, Windows Graphics Foundation 2.0, and most recently, Direct3D10. The naming situation will clear up as we get closer to the official Windows Vista release, but all you have to know is that DirectX 10 and Direct3D10 in particular will introduce a new era in PC gaming.

Microsoft’s DirectX APIs are a collection of interfaces that standardize how game developers talk to PC system hardware. It’s a lot easier for programmers to write for a single DirectSound or Direct3D API, instead of writing for every single video card and sound card in existence. Microsoft rebuilt its Direct3D API from scratch for Windows Vista, and Direct3D10 will serve as the base for all future Direct3D innovations throughout the life span of the Windows Vista operating system.

Because the Direct3D10 foundation has to serve game developers through the next decade, Windows Vista will streamline and open up Direct3D with several forward-looking features that will help programmers create better games and get more performance out of PC hardware.

All hail the graphics processing unit
Direct3D10 finally completes the break from the legacy fixed-function pipeline. Developers will use the programmable pipeline to emulate the older, fixed-function steps. Additionally, Microsoft had to rethink its display driver model now that the entire desktop is going 3D. The video card isn’t just for games anymore. When you have a 3D desktop and give each application its own 3D window, the display driver has to be flexible and stable enough to handle the video card’s increased role in the system. Microsoft split up the display driver to increase stability, to ensure that the 3D desktop stays up in the event that a game or another application crashes due to a graphics error. This change also means that Microsoft will not release DirectX 10 for Windows XP, because many of the Direct3D10 improvements will need the new Windows Vista Display Driver Model.

Opening up the video card to more applications will require Vista to give the GPU more system resources and allow applications to share the hardware. The biggest change for game developers will be virtualized memory for the GPU. The video card will now have its own space in system RAM to store information that can’t fit on local video card memory. High-end video cards ship with 256MB or 512MB of memory, but games can still use the extra space in system memory to store large chunks of information, like textures.

Epic Games founder Tim Sweeney explains, “Virtual texturing eliminates the video memory bottleneck on texture size; whereas in DirectX 9 the size of textures we can use with full performance is limited by the amount of video memory, in DirectX 10 it is only limited by total system memory.” Furthermore, Tim predicts that virtual memory will enable a “2X-4X increase in texture usage in games, which will be great for Unreal Engine 3 games, where textures are often authored at very high resolutions like 2048×2048, and then scaled down on lower-end systems to improve performance.”

Setting standards and improving performance
Video cards will now have strict feature-set requirements for Direct3D10. A video card must have the full feature set to be DirectX 10 approved. This isn’t a whole lot different from the existing model, in which a card has to have certain features to be DirectX 9.0c or Shader Model 2.0 compliant, but Microsoft has made the specification much more detailed to remove any chance of hardware variation. Differences in how Nvidia and ATI cards handled floating-point precision created extra work for developers in the past, but tighter Direct3D10 specifications will help remove ambiguous areas in hardware design. Having consistent hardware means programmers can avoid spending development time on customizing games for cards that don’t have all the necessary features or have odd implementations.

Microsoft plans to accelerate its Direct3D release schedule to keep up as the graphics manufacturers release new GPUs with advanced features. If everything goes as planned, the game developer will have to learn only Direct3D11, instead of figuring out the quirks for two different GPUs when Nvidia and ATI release a new technology round. However, this change might not mean the end of writing code for specific GPUs. While developers can count on DX10 to define card features sets, the Microsoft DirectX team admits that “we may see [hardware vendors] putting in additional differentiating features, which developers may want to natively support.”

Now on News.com:

• Wal-Mart takes shine to solar power
• Detecting PC-made child pornography
• New year brings familiar security threats
• Extra: Rich Skrenta: Google won already

DirectX 10 will increase game performance by as much as six to eight times. Much of that will be accomplished with smarter resource management, improving API and driver efficiencies, and moving more work from the CPU to the GPU. “The entire API and pipeline have been redesigned from the ground up to maximize performance and minimize CPU and bandwidth overhead,” according to Microsoft. Furthermore, “the idea behind D3D10 is to maximize what the GPU can do without CPU interaction, and when the CPU is needed it’s a fast, streamlined, pipeline-able operation.” Giving the GPU more efficient ways to write and access data will reduce CPU overhead costs by keeping more of the work on the video card.

Here’s a list of several new Direct3D 10 performance improvements GameSpot was able to wrestle out of the DirectX 10 team:

• New constant buffers maximize efficiency of sending shader constant data (light positions, material information, etc.) to the GPU by eliminating redundancy and massively reducing the number of calls to the runtime and driver.

• New state objects significantly reduce the amount of API calls and bandwidth, tracking, mapping, and validation overhead needed in the runtime and driver to change GPU device state.

• Texture arrays enable the GPU to swap materials on-the-fly without having to swap those textures from the CPU.

• Resource views enable super-fast binding of resources to the pipeline by informing the system early-on about its intended use. This also vastly reduces the cost of hazard-tracking and validation.

• Predicated rendering allows draw calls to be automatically deactivated based on the results of previous rendering–without any CPU interaction. This enables rapid occlusion culling to avoid rendering objects that aren’t visible. Shader Model 4.0 provides a more robust instruction set with capabilities like integer and bitwise instructions, enabling more work to be transferred to the GPU.

• The D3D runtime itself has been completely refactored to maximize performance and configurability by the application.

It remains to be seen just how well actual DX10 graphics hardware will be able to handle the additional work, but we’ve seen in the past that ATI and Nvidia have been able to deliver whenever games have shifted work from the CPU to the GPU.

Now a comparison between Direct3D tt’s Competitior OpenGL

In general, Direct3D is designed to be a 3D hardware interface. The feature set of D3D is derived from the feature set of what hardware provides. OpenGL, on the other hand, is designed to be a 3D rendering system that may be hardware accelerated. These two API’s are fundamentally designed under two separate modes of thought. The fact that the two APIs have become so similar in functionality shows how well hardware is converging into user functionality.

Even so, there are functional differences in how the two APIs work. Direct3D expects the application to manage hardware resources; OpenGL makes the implementation do it. This makes it much easier for the user in terms of writing a valid application, but it leaves the user more susceptible to implementation bugs that the user may be unable to fix. At the same time, because OpenGL hides hardware details (including whether hardware is even being used), the user is unable to query the status of various hardware resources. So the user must trust that the implementation is using hardware resources “Optimally”.

Professional graphics

OpenGL has always seen more use in the professional graphics market than DirectX (Microsoft even acknowledges OpenGL’s advantage in this field^{[citation needed]}), while DirectX is used mostly for computer games. (The term professional is used here to refer to the professional production of graphics, such as in computer animated films, as opposed to games where the graphics produced by the game are for the user’s personal, rather than professional, use.)

At one point many professional graphics cards only supported OpenGL, however, nowadays all the major professional card manufacturers (Nvidia, ATI Technologies and Matrox) support both OpenGL and Direct3D.

Gaming

The principal reason for Direct3D’s dominance in the gaming industry is historical. In the earliest days of hardware-accelerated 3D graphics, 3dfx was the dominant force, and their Glide API was used by far more games than D3D or OpenGL. Glide was much lower-level than D3D or OpenGL, and thus its performance was greater than either. Performance is the most important facet for game developers, so the less easy to use Glide API was preferred over the other two. This helped catapult 3DFx into the forefront of 3D hardware in those days.

As hardware got faster, however, the performance advantages of Glide began to be outweighted by the ease of use. Also, because Glide was restricted to 3dfx hardware, and 3dfx was not being as smart about hardware design as its main competitor nVidia, a hardware neutral API was needed. The very earliest versions of Direct3D (part of DirectX version 3) was not the simplest API to use. The next Direct3D version (in DirectX 5) was much more lucid. As interest in making Glide only games or games with multiple renderers dropped, there was a choice to make: OpenGL or Direct3D 5.

Making games that use OpenGL while using the non-Direct3D portion of the DirectX API is no more difficult than making a game using all of the DirectX API. The decision to use Direct3D over OpenGL was made from simple pragmatism: in those days, OpenGL implementations were difficult to work with. Writing an OpenGL implementation requires implementing every feature of OpenGL, even if the hardware doesn’t support it. If the hardware can’t do it, you have to write a software rasterizer that can handle that feature.

Different GL implementations would, when activating some feature, spontaneously go into a slow software renderer. Because OpenGL has no mechanism for telling the user whether or not a feature, or combination of features, will kick the renderer into software mode, users of OpenGL had to carefully test everything that they did on every piece of hardware that they were going to support.

Adding to that is the fact that an OpenGL implementation is a complex piece of code. It is much more than a simple graphics driver that is just a low-level interface to hardware registers. It needs to keep track of a great deal of state information, and that requires a lot of code.  However, in a game situation, where a loss of performance can destroy the feeling of the game, it is more desirable to know that the functionality doesn’t exist and to simply avoid using it.

Direct3D didn’t have these problems. A Direct3D driver is (or, was in those days) just a low-level interface to hardware registers. And D3D has a query mechanism that tells the application whether or not a particular feature is available in hardware. So game developers chose to use it because it did what they needed.

At this point, the Windows Vista issue aside, the reason for using one over the other is typically inertia. It is what they have used in the past, so it is what they use now.

————————–