Skip to main content

DirectX SDK (August 2009) released

Finally the DX SDK August 2009 has been released, which contains the RTM version of DirectX 11. Moreover, it also brings back the effects framework for DX11, which was missing in the March SDK. Grab it at the Microsoft Download Centre while it's hot.

Some things are still not supported, especially PIX is not able to debug compute shaders at the moment. On Vista, it may require a patch to work (KB971644), which is not up yet, so you should run Windows 7 if possible.

[Update] The update for Windows Vista can be now downloaded. It's actually a larger platform update (and currently beta), which also brings the Scenic Ribbon from Windows 7 back to Vista. Took me a few tries before the download centre would display the update (previously, I got "page not found"), so be patient.

[Update] The update is not working on localised Vista versions, I could install it on an US Vista, but not on a German one. Specifically, it fails to to install "Windows6.0-KB971512-x64", which contains the d3d11.dll (among other things). I'll update this post again if I get it working, in the meantime, use an US Vista. Setting the language options to English (US) is not enough.

[Update] Got two confirmations from Microsoft, it is indeed only working on en_US Vista installations. The final release will work with localised versions as well. That's a annoying, as I don't get why I have to wait for potentially weeks just because I cannot change my Vista locale.

[Update] The final version has been released.

Using CMake to build a Qt application

CMake is a really great build tool, and it makes it very easy to use a lot of libraries with it. For example, CMake has a built-in module that helps you to set up a Qt project. Unfortunately, it's a bit tricky to get started with it, so this post provides you a quick getting started guide to create a typical Qt application. For most of the time, we have to deal with three Qt related file types (besides .cpp and .h): .qrc, .ui and .h/.cpp files which contain Q_OBJECT enabled classes.


.qrc contain resources, and are the easiest to handle. The Qt resource compiler (rcc) simply creates a single .cpp file, and puts all resources as static arrays into it. The corresponding CMake function is QT4_ADD_RESOURCES. The first parameter is the output, which you have to add to your source file list.


For the .ui files, the UI-compiler has to be called first (uic) which generates a header file; this header contains all the logic to set up your user interface. You include this generated header in your source files, and use it to display the UI. How does this look like in practice? Well, let's assume we have a file "testDialog.ui", which contains the UI, and we want to implement a dialog using this UI. We create a custom class, for example, TestDialog, which is derived from QDialog. This class is put into TestDialog.h/.cpp, and may look like this:

#include "ui_TestDialog.h"

class TestDialog : public QDialog

    TestDialog ();

public slots:
public signals:

    Ui::TestDialog ui;


The "ui_TestDialog.h" file is generated by the user interface compiler (uic), using the QT4_WRAP_UI command. The output is directly into the output folder, so you should add INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR}) to your project file -- otherwise, the files won't be found. In your dialog constructor, you can init the UI now using:

ui.setupUi (this);

QObject derived

Running the meta-object compiler for QObject derived classes is similar to resources, you add QT4_WRAP_CPP in your CMake file, and just add the generated files to your source files. The input for this function is the header of your class, not the implementation -- even though it's called QT4_WRAP_CPP, you must pass the file containing the declaration; this is usually the header. Those files contain a bunch of functions which are needed for the Qt meta-object system. These are stand-alone .cpp files that you usually never have to look at.


I usually wind up including all generated files to my project, so I can debug into them. To generate clean project files for Visual Studio, you should use source groups (check out the SOURCE_GROUP command) -- be careful though, as the files end up in the current build directory. That's it, you should be ready to create Qt applications with CMake! Feel free to ask questions if something is unclear, so I can update the post.

Carmack’s 2009 keynote

Even though QuakeCon 2009 is over since quite some time, I just got around to watch the keynote a few days ago. At first it is a bit slow-going when Carmack starts how great the guys at Bethesda are, and other business stuff. Obviously, they are still quite free even though they have been bought, but the future will tell whether this deal is all that great as they talk about it at the moment.


There's less technical stuff than usual in my opinion, especially no forward-looking stuff at all as Carmack didn't have time for R&D yet. He still believes that voxel rendering is the way forward, and while I tend to agree with this somewhat, I don't see at the moment how to make a game engine on a voxel renderer right now (and going hybrid with triangle and voxel rendering is an interesting problem). Besides this, he mentions that the virtual texture mapping stuff took quite a lot of time and it's still not as usable as the artists would like it to be. The updates are still taking a bit too long, and by looking at their SIGGRAPH presentation this is obviously down to the fact that they use extreme compression and lots and lots of trickery to improve runtime performance, trading off edit time for it big-time. This is for example totally different from what Crytek does, where they try to minimise offline processing as much as possible (no precomputed lighting for example, while Rage uses a radiosity solution for all the outdoor lighting).

Near the end, he also talks a bit about threading game code and scripting languages. At id, they want to keep the game code single-threaded so that programming and debugging becomes easier, and move all computationally intense systems to threads (collision detection, etc.). What makes me wonder is that he says that they prefer C++ code over script code for easier debugging, which sounds kinda weird at best.

Another interesting tidbit: They use Oracle Enterprise as the database backend for Quake Live, and Carmack complains that this is extremely expensive, so that scaling by increasing the database cluster was out of question when they hit the first performance problems. Weird that they didn't choose PostgreSQL, as I don't see any advantage of using Oracle for this (after all, this is not a bank account system ...). On the other hand, Oracle seems to be popular among game developers, as World of Warcraft is also likely running on Oracle (at least they always look for people with Oracle experience).

Production stuff & mobile division

Most of the talk focuses on production issues, which are interesting to hear for someone who is not working in a game company. For Rage, they really try to make sure that everything is working right -- they spend a huge amount of time on tiny details, to make sure that the game is really polished.

A big chunk of the keynote is devoted to the mobile division at id. They seem to be re-use lots of their old games with pretty good success, and Carmack seems to like this small-scale development a lot. For the future, they are going to focus on the iPhone, which is a bit unfortunate in my opinion as very nice devices are coming out with Linux -- the Nokia N900 for instance (in this particular case, running Maemo -- a mobile Linux which I expect to be used broadly in the future).


Pretty interesting summary this year, if you want to watch it on your own, check out the video coverage on Quake Unity. No need to take the HD version though; could have been a pod-cast just as well.

Boost 1.40 released

Just saw it, Boost 1.40 has been released. Contains a few fixes for GCC 4.4 and VC 10 (great!), performance improvements and loads of other bugfixes. Asio has also got a lot of updates. The build system has been slightly modified (for 64bit Linux, the target architecture is no longer required). Didn't try yet, but from the changelog I don't expect any problems.