When Adobe acquired Macromedia, a lot of people thought that’d be the end of Director. After all, Director and Flash have had increasingly overlapping capabilities for some time, and Director seemed like something people used years ago. Think again: talk to people doing interactive design, and Director — for better or worse — lives on.

With the Director 11 update announced this week, that’s unlikely to change any time soon. New in this release:

• Vista support on Windows, Intel support on Mac
• Bitmap filters (a la the bitmap API in Flash 8/9, I’m assuming)
• Full JavaScript support and Code Snippets
• Enhanced Flash support with CS3 and Flash Video support
• Built-in physics via AGEIA PhysX
• Native DirectX 9 3D support

Now, anyone for a Voyager interactive CD-ROM (as pictured right, from the Director heyday)?

Physics and 3D? Impressive stuff. So I should be excited, right?

3D goodness means getting cozy with your local graphics API — and getting ready to nerd out in a big way. OpenGL continues to progress with a major overhaul. It’s a way off, but you’ve still got lots of eye candy with OpenGL 2.1. So … if you’re not Electronic Arts or Bungie, is there really any reason to use DirectX?

With the release of Windows Vista, we’ve been hearing a lot about DirectX, Microsoft’s Windows-only API for accessing graphics hardware. Of course, most of what you’ve been hearing is Windows gaming lovers complaining because they have to upgrade to Vista just to get DirectX 10 — and they take a compatibility and performance hit for many existing games as a result. (The latter isn’t DirectX 10’s fault; it’s a side effect of a new driver and display model in Vista itself, which impacts OpenGL and DX9, as well.) So what’s going on in the OpenGL camp? At SIGGRAPH, OpenGL 3 was announced. The full spec isn’t available yet, and actual OpenGL 3 hardware will be some ways off, but the future looks bright. In a presentation on the new OpenGL, NVIDIA’s Michael Gold pointed to these major hallmarks:

• Getting “back to the bare metal” for performance. This includes cutting back on overhead, streamlining the API, and actually revamping the object model in a way that should boost raw speed.
• Simpler, more efficient application development.
• Simpler driver development.

So that all sounds good. The object model appears to be the major change, with new object meta-classes that make it easier and more efficient to, well, make stuff. Good luck deciphering this at this point (I expect it’ll be easier once the real spec is out), but here’s more on the announcement, with slides:

OpenGL 3.0 Birds of a Feather at SIGGRAPH
PDF with slides, via NVIDIA’s Michael Gold

Us visualists, of course, can leave most of this to developers and hardware makers. What’s nice is that when we do want to make things look slick, we have access to a cross-platform 3D API in tools like Processing/Java, Pure Data (via GEM, etc.), and Max/MSP/Jitter.

As it happens, I’ve been looking at both OpenGL and DirectX solutions while putting together tools and frameworks to do new 3D work.

As someone relatively new to Processing, I’ve experienced equal parts excitement and frustration. 0115 is a reasonably mature build, and I’m glad I didn’t try this earlier, but more advanced work is likely to get easier as the software develops, improves, and squashes bugs.

Before I dive into the full, technical explanation for those of you using Processing, here’s the Cliff Notes version:

1. Processing is great, but think of it as a sketchpad — and “beta” is accurate; prepare to hit up against some limitations that could become a time suck if your project is dependent on them.
2. OpenGL rendering works, but has major limitations when mixing pixel processing. Then again, you’ll want to use Processing’s other built-in rendering engines so you can share your work on the Web, so try those, and consider waiting on your OpenGL sketches until the bugs are fixed.
3. Video capture on Windows (and Mac, to a lesser extent) can be a pain because of QuickTime for Java. JMyron works around this on Windows with DirectX, but there is an important caveat; again, you may find things feel like a work in progress.
4. JMyron is fantastic for doing simple motion tracking without a lot of coding. (Here’s where Processing wins; Jitter and cv.jit, for instance, are much harder to use in this area.) Example image below from JMyron’s site.

Interesting example of using JMyron/Processing: Shadow Monsters [Pixelsumo entry]

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.