Anteru’s blog

If you are serious about programming, you know this feeling: You start working with something, and after some while, you hit some kind of road-block. Looking around for an easy fix, you find out that version N+1 is going to solve this problem. And now you postpone this nasty feature and start waiting for N+1 … like for example:

• .NET 3.5 SP1: If you are doing WPF now, SP1 is the next big release of it. Vastly improved designer support in VS2008, better performance, easier usage, new GUI widgets.
• VS2008 SP1: Finally TR1 support and more … (note: supposed to be released today!)
• DX11: Built-in tesselation support, no need to implement it on your own! Shader linkage, etc.
• Mono 2.0: Finally most of C# 3.0 on Linux, so you can eventually start working for Linux
• Firefox 3.1: You want to use videos on your homepage? Just wait for 3.1, which will make everything simpler by supporting videos out-of-the-box
• C++0x: Will make the world a better place to be (seriously ), at least as long as you are a C++ developer.
  • A compiler for C++0x
• OOo 3.0: Ahh, finally notes/comments, how can I live without them currently?
• Larabee: A truly programmable GPU

And the list goes on. Looking at it, I wonder how it is possible to do something right now — surely, our tools must be extremely bad if each new revision brings lots of revolutionary improvements. I find myself quite often thinking “it’s not worth to spend time with this here, the next gen is around the corner”, but if you look back at the last 10 years or so you’ll notice a few things:

1. Updates cause problems. While 10 things work, one will be broken, and fixed in the next release again. This is getting better actually, but it’ll come and get you anyway.
2. The updates bring nothing really new to the table. Sure, some things might get slightly simpler or more comfortable with each new release, but they are not going to improve your productivity by 100%. For sure, in the time you wait for them, you’ll be able to implement that feature, even if it takes 10% longer with the current version.

It’s not like C++0x will allow us to rewrite whole applications to be vastly simpler. Same goes for example for C# 3.0: While it brings really nice additions on the table (lambda functions, LINQ), this is not going to help you writing your next game engine twice as fast. The increments are rather getting smaller.

Don’t get me wrong. I’m not advocating to never upgrade and always work with old stuff; I’m on the bleeding edge usually. Just don’t wait for the new stuff, but take a look at it when it comes out — it might indeed make your life simpler, but waiting for it is not worth it. If you really have to do something, you can do it right now — just shut up and do.

Simple ray-tracer screenshot

Over the last two days, I’ve written an extremely simple ray-tracer in C#, just as a proof of concept that this can be done in less than two hours, even without preparation. See attached screenshot…

In comparison, writing a simple ray/sphere intersection routine in HLSL took roughly 10 minutes, including phong lightning on the hit-point and binding the light to a FX Composer external light source, plus the performance was much more impressive

Max Kor has released an interesting “tutorial” (actually, a short overview of the creation process) about his absolutely incredible night elf image. Really worth a look, fantastic work!

Aqsis has been accepted into Google’s Summer of Code program. If you are a student, and interested in 3D, I can just recommend to check this out. The Aqsis Team is a friendly, highly-talented group of people, and if you have some spare time I bet you’ll enjoy working with them. Moreover, you can earn some money