in Conferences and events

A Whirlwind Tour Through GDC 2006

Spring was supposed to be the season of flowers, new leaves, and good weather returning. Here in San Diego we don’t get much of that, or rather, we get it all year around. So Spring can really sneak up on you, and before you realize it, it’s already gone. Spring also seems to be the season for game-development conferences and travel: just a few weeks apart we get Sony’s conference, Microsoft’s, and, of course, GDC. I’m not even going to count Dice and E3, also happening around the same time.

With all that going on, I realized I never got around to writing my impressions about GDC. It really was a great conference with some very good highlights. My travel is far from over, and I’m heading out to the airport to catch my plane to London in a couple of hours, but until then, here is my quick take on this year’s GDC.

This year I decided to come for the tutorials happening two days before the main conference. The first day I bounced between “Advanced Visual Effects with OpenGL” and “Software Engineering Issues in Multiplayer Games.”

The OpenGL tutorial was exactly what you would expect: lots of material from previous years and a few good bits of information. The first thing I was happy to learn is that Microsoft changed their decision on how OpenGL will be implemented in Vista. It will no longer be a layer on top of DirectX; instead it will be a first-class citizen in its own right. Now, I’m not an OpenGL fan. Up until recently I never had to work much with it, and now that I have, I admit that I like the Direct3D API much better (I’m just not a fan of implicit global states). But I’m very glad to see that OpenGL is going to be treated correctly in Vista and given the opportunity to compete with Direct3D.

I was also pleasantly surprised by the tools NVidia is releasing for OpenGL development. NVPerfKit is a bit like Pix for DirectX; combined with gDebugger, it starts making OpenGL a lot more attractive. They’re supposed to release version 2.0 soon, but I didn’t find it on their web site. It’s really interesting how much NVidia is pushing OpenGL lately. At one point it felt that it was over for OpenGL, but it really has been making a comeback in the last couple of years. Now if they can only improve Cg…

The tutorial “Software Engineering Issues in Multiplayer Games” managed to surprise me, and I wish I had spent longer there than I did. It really was focused on the software engineering aspects, rather than on the multiplayer part of it. Lots of good information and war stories of large-scale game development.

Tuesday I spent it exclusively in the Direct3D tutorial. The biggest new thing was DirectX 10, with several talks focused on that. Apart from the new cool tech features (such as the stream out feature or the geometry shaders), DirectX 10 is quite a departure from earlier versions of the API. A couple of things make me scratch my head in puzzlement. DirectX 10 supposedly won’t have any caps to query anymore. Hardware is either DirectX 10 compliant or it isn’t. That’s great news for developers. However, I also learned that DirectX 10 is going to be tied to the Vista operating system, and new versions of DirectX will only be released as part of new versions of Windows. Unless I’m missing something, that means that hardware won’t have an opportunity to change and grow while running on Vista. That would be horrible for hardware manufacturers, but at least they have OpenGL to show their new features. Or maybe it means that Microsoft is planning on doing a yearly operating system release. It will be interesting to see how it plays out.

The best session on Tuesday was clearly Natalya Tatarchuk’s talk on the Toy Shop demo. She spent a full hour dissecting the demo, covering every rendering trick and effect they used. Considering how impressive and packed the demo is, it was clear that she could have spent a full day talking about it. Some effects are awesome, like their smeared rain reflections on the road, but it was funny to see how they clearly spent quite a bit of time doing things that are completely lost, like diffraction on the light that goes through the droplets on the store window. In any case, if you haven’t seen the demo, download it right now.

Wednesday was the start of the main GDC sessions. To kick things off, Sean and I gave our talk on test-driven development. I was really surprised at how packed the room was and how well received it was, judging by all the questions and positive comments. It’s great to see that other people are also very interested in TDD and are thinking about applying to it game development.

The next-generation animation panel was pretty interesting as an overview of what could be coming down the pipe for animation. I was already familiar with most of the content except for Ken Perlin‘s new foot-placement work, but it was a great overview anyway. I’ve been quite excited about data-driven animation for a couple of years, and Lucas Kovar‘s work is very promising. I think the only thing holding that technique back from being applied to games is the memory requirements, but I would love to spend some time trying to make it practical. Victor Zordan‘s work is also very promising, combining dynamics with data from motion capture, which would be great for games (using ragdolls to predict and blend into falling animations for example).

Thursday was definitely the big day (for sessions, although that’s always the biggest day for parties too). The day started with the excellent session on “Advanced Prototyping” by Chris Hecker and Chaim Gingold. I really can’t say enough good things about it: it was packed with interesting, non-obvious information, it was very well presented and full of energy (it’s Chris we’re talking about, so of course it is!), and extremely motivational. They did a top-notch job preparing for the presentation and it showed. The pair had a very interesting presentation style that felt almost like a conversation between them two, and it worked very well. It was hands-down the best session of GDC for me. The talk covered things like why you want to prototype, what constitutes a good prototype, how you go about prototyping things, what to prototype and what to leave out, how to put the results together, etc, etc.

I don’t really understand why it was classified under the game design track. It really was more of a programming, production, or just all-around session. Even so, apparently the session was full and they had to turn people away. I really hope that they recorded it on video and they make it available online.

At one point they described what they considered to be a good codebase for prototyping. The funny thing is, I completely agree with every point they brought up, but for me those are characteristics I want in any codebase, not just one for prototyping. They are all things I value very much: ability to change, flexible, code vs. content, use of scripting, etc. In particular, the comment of frameworks vs. toolsets really hit the mark. That’s something I’ve been pitching for a while, but I really consider frameworks to be fundamentally broken for the type of development I want to do. Instead, I want a set of tools (functions, classes, whatever) that I can put together in any way I want instead of being constrained to one predefined structure (even if it has hundreds of callbacks, like MFC).

I think I was the only person in the packed Civic Auditorium left cold by the Nintendo keynote. Yes, it’s great to have Satoru Iwata give a GDC keynote, but I really didn’t connect with his speaking style or his message. I found it content-free and not very engaging (it didn’t help any that I was stuck in a corner of the top balcony—apparently there was a screen in the middle of the stage that I was not able to see that explained a lot of his strange comments).

On the other hand, Will Wright‘s keynote was just the bomb. Somehow every year he manages to deliver amazing talk after amazing talk. I knew I really wanted to hear his session, so I chose to stay in the auditorium instead of going out again to get a free DS game and have to wait through that whole line. Good choice! I was able to get the best seat in the house this time around.

Will’s keynote cannot really be described in one paragraph. People have asked me what it was about, and I’m left without words. The point is not what it was about, it was the whole experience! It’s like being 12 years old again and going to a summer blockbuster that hits you from the beginning and doesn’t let you go for the next two hours. I left the auditorium dazzled and super-motivated. Isn’t that enough?

On the surface, the talk was about how he goes about researching new projects, interleaved with what he learned about astrobiology for the development of Spore. You can try getting more of an idea what it was about here and here (and a short video here). That’s another talk I hope GDC puts online very soon.

I have to admit, that after Will’s keynote, the rest of GDC was fairly anticlimactic. Maybe next time they should leave it for the last day to build up the grand finale. The only session that I attended that really stands out was Tim Moss’ God of War talk. I was expecting something a bit different, but it turned out to be a mini-postmortem of God of War. In particular, he talked about how they were organized, what their priorities were, and how they went about solving problems. I found it very interesting on many different levels, but the most interesting part was that they do things very differently to how I would go about doing them (or how we’re doing them at work right now). They also have a very different set of constraints: they have a very small number of very senior programmers, so they do anything they can to minimize using their time. They end up developing very general solutions, while right now I would advocate for the very specific solutions. It’s clear that their approach worked very well for them, so it’s great to see how different teams can tackle different problems in a variety of ways.

One pattern I noticed in this year’s GDC is that, for technical talks, the more general the talk, the more I enjoyed it. As soon as they got bogged down in details, they became much less effective. A lot of it has to do with the dry nature of the topics, and the fact that I can get all those details from a well-written paper. On the other hand, the more general talks (advanced prototyping, Will’s keynote, or the God of War one) were all very motivational and inspirational. In the end of the day, that’s what GDC is about for me: inspiration and socializing. And this year’s GDC was a huge success by that measure.

  • Hi Noel,

    I’m the CA (guy in the orange shirt) who asked at your presentation whether, if you test two classes against mocks of each other, the two can grow apart. I work for a 3D IM company and we have BuddyState and BuddyWindow classes. The former manages communication with the server and passes change events to the latter, which updates the actual UI. The interface between the two is quite narrow: just a single “hereIsAnEvent” callback. I haven’t yet had a situation where one of the classes changed in a way that broke the app as a whole but still passed the tests, so it was more of a theoretical question… Some people on the TDD mailing list talk about integration tests (MockServer -> BuddyState -> BuddyWindow -> MockBuddyUi), but it seems kind of difficult or pointless to write tests for the individual components ((MockServer -> BuddyState -> MockBuddyWindow) and (MockBuddyState -> MockBuddyWindow -> MockBuddyUi)) _and_ the buddy system as a whole. Rather, I can’t seem to figure out how to capture the essential notion of “BuddyState sends messages in a way that make sense to the actual UI”. Maybe it’s just academic. Or maybe customer tests solve the problem. Thoughts?

    Anyway, we’re practicing TDD in three languages: C++, Python, and PHP. Your articles test-infected me, and now I’m converting others, so thanks. 🙂

    Cheers and nice presentation,

    Chad Austin


  • Regarding D3D10 ‘growing’ during Vista. Someone asked the same question in a different D3D10 talk (or maybe you had skipped out). It sounds like the current plans are to have a similar group of features that HAVE to be implemented and call it D3D10.1, .2 etc. The ahrdware vendors have to support that set. So caps bits will return but they will be as simple as ‘Are you a D3D10.2 card’ and if so you instantly know the entire feature set they support. So basically a single caps bit per API upgrade. And by API upgrade I don’t mean the bi monthly SDK update.

  • GDC’s Nintendo Keynote, Game Developer Perspectives

    Yes, yes, we know it’s a little while after the show, but there’s still some interesting GDC-related videos and reports wandering out there onto the wide world of the Interweb.

  • ZMan, that’s right about the “updates” to D3D10. But it still means that there will be no hardware improvements until a new API is released. That combined with the API tied to new OS releases, changes things quite a bit from how they are now. Unless you’re saying that the API will change more frequently than the SDK? Anybody have any good links from Microsoft explaining this?

  • Finally! Someone else that was left pretty unimpressed with Iwata’s keynote!

    It was amazing to see everyone after the session babbling about how impressive his keynote was, when all I got out of it, to paraphrase a friend, was “You guys take the risk and we (Nintendo) will keep on doing the safe thing, by churning out more Mario, Zelda and Metroid games”.

    The talk you and Sean gave on TDD really hammered it home for me. Put the fire in my belly, so to speak, to actually start doing it in the code that I’m writing. As a suggestion for next year, if you decided to do another TDD presentation, one thing I would suggest is actually have a block on ‘how’ to write a good test. I think that would be invaluable to all the folks new to TDD (I know it would really help me out).

  • weshunt

    Quote: “But it still means that there will be no hardware improvements until a new API is released.”

    Sure, but how is the different than now with DX9? If there isn’t a caps bit there, vendors can’t expose it without “back-door” hacks. If the updates come even every 6 months, its more frequent than we get now.

    It’s the elimination of the caps bits that the real difference, and a welcome relief if the IHVs can all agree on high-level features they want to implement. This has the potential to turn the PC into a much more manageable set of discrete “platforms” like Xbox and 360. As to whether the reality will be so, we’ll have to see.