One major carrot Microsoft is holding out to convince people to upgrade to Vista some time next year is the broadly-overhauled DirectX 10. I’m skeptical about many of the new features in Vista, but I have to say, DirectX 10 is tempting, at least based on what we know now. Details are somewhat sketchy, but it sounds like Microsoft has done a lot of work to overhaul the 3D graphics API in Windows. The best information so far has come from ExtremeTech:

DirectX 10 interview [ExtremeTech podcasts]

More details emerge about DirectX 10 [Ars Technica; primarily analysis of ExtremeTech's interview]

Two revelations come out of this podcast: first, someone at Microsoft or ExtremeTech knows jack about audio fidelity. (A little bad? It sounds like you were talking via a satellite phone. To Mars.) Second, DirectX 10 will have plenty to offer. Here’s where we’re really lucky: those of us using 3D for interactive art don’t have to worry about the issues game developers have to worry about. We don’t have to wait for customers to upgrade to new graphics cards and Vista software, because we can do that whenever we want. DirectX 10 promises some really fantastic eye candy and capabilities, and many of these you’ll be able to take advantage of soon — some, even before DirectX 10 and Vista become available to the public. Here’s why your eyes should care.

To understand why this is important, first you need to understand a little bit about shaders — and, based on what I’ve read in the press, most of the press are fuzzy on these issues. Shaders are bits of code that run natively on the graphics card to process 3D output. There are two basic types: vertex shaders, which process the geometry of the models output to the graphics card one vertex at a time, and pixel shaders, which do the actual “shading” of color, light, shadows, and fog. Vertex shaders are really quite simple and common. Any time you’ve rotated a 3D model (Jitter users, check out jit.gl.handle), you’ve been using a vertex shader.

Here’s the tricky part: Microsoft is unveiling something they’re calling a “geometry shader.” That’s confusing, because a vertex shader essentially is a geometry shader. Apparently what’s new here isn’t the ability to modify vertices, but the ability to do so with new levels of performance and flexibility. Modifying entire vertices at once becomes simpler with geometry-wide shaders, and new capabilities are possible with geometry shaders that were either impossible or difficult with vertex shaders. I don’t think anyone will have a solid handle on what this means until they start working with geometry shaders directly, and even then, shader development is not a monolithic process — people are constantly coming up with idiosyncratic techniques and tricks. But it does sound as though processes like ripple distortions (waving a flag or doing fluid simulations) and other geometry-wide techniques will become easier, faster, or both with geometry shaders.

More clear are the advantages of DirectX 10 for transferring data back from the GPU to the CPU. By making this substantially easier and faster, Microsoft is working to clear one of the major bottlenecks in doing 3D. What excites me is that the DirectX developers mentioned the ability to do processes like edge detection and feed those results back to the CPU, which for the would allow more efficient GPU-native motion detection for video tracking applications. It’s always been possible to hack together particle systems using GPUs, as well, but DirectX 10 sounds as though it will offer expanded capabilities there, too.

I think smart artists and programmers will enjoy these capabilities more quickly than game developers, because you can work with them directly. The video / VJ toolkit vvvv, notably, is based on DirectX, so I hope those developers will provide access to these new features. I don’t expect to see DirectX 10 in Jitter, since it’s Windows-only, but that brings me to the next point:

OpenGL lives in Vista, contrary to early indications. Originally, the OpenGL consortium was concerned that Microsoft would only provide OpenGL support through a Direct3D wrapper, which would evidentally have had a devastating impact on performance and compatibility. Now, there are three options under Vista, detailed by Microsoft developer Kam VedBrat on his blog. Legacy drivers will disable the new windowing manager, so if you don’t update your drivers, OpenGL apps will make those transparent Aero edges on your windows. (Supposedly, that’s a bad thing. I’ll try to pretend to be disappointed.) Fortunately, new drivers will let you run your OpenGL apps (like SketchUp) natively on Vista in a mode completely compatible with the Aero windowing environment. It sounds as though Microsoft was considering hobbling OpenGL support under Vista, but outcry from software and hardware developers changed their mind.

Anyway, the bottom line is that OpenGL lives on. And until I see solid evidence that DirectX 10 is worth switching, staying platform-independent has a lot of appeal. One major difference in OpenGL is that it scales to more hardware, which I suspect is part of the reason the Mac OS X interface can run on a broader variety of graphics cards than Microsoft’s new Aero interface.

if you’re interested in learning more, Wikipedia has some superb resources on both technologies:

OpenGL
DirectX

And if you’re ready to join the Bleeding Edge Club, Microsoft has a tech preview of the DirectX 10 SDK:

DirectX SDK @ MSDN

  • Ivan Vucica

    I'd also like to note that OpenGL will probably support the important new features of DirectX. In fact, that way, Wine developers (a GNU/Linux program to run Windows programs) hope to backport DirectX10 to Windows XP — they will have to do it anyways for GNU/Linux, so they'll just try to make it run under XP.