Hi all - just to let you know the DeveloperDeveloperDeveloper event is coming along a treat - thanks to the tireless efforts of Craig Murphy, Benjamin Mitchell and Phil Winstanley, not to mention Microsoft's very own Sarah Brown (who is as yet not of the blogosphere. Come on Sarah...)

If you haven't registered yet and fancy spending a Saturday chez Microsoft with your fellow .NET fans, users, critics, and of course the floating voters, you can register here. The agenda's here; it's a fantastic mix of the technical and the slightly-less-technical and we can promise you a very enjoyable and thought-provoking day, punctuated by lunch and the odd chocky bikky.

That said, the word's got round and we're close to 85% of the capacity of our three big meeting rooms, so if you would like to come along now would be a very good time to reserve your spot. If you fancy speaking at a future event, to share your experiences and insights, this would be a great opportunity too to meet Craig, Phil and Benjamin and help them shape the agenda for the next DeveloperDeveloperDeveloper; be assured they're men of integrity so cheap bribes like "I saved you the last Bourbon" won't influence them in any way :-)

We look forward to seeing you there!

I promised another book recommendation and then failed to deliver, so I owe the remarkable Andrew Whitechapel an apology.

My latest passion is for rabbiting about developing for Office in managed code. If your perception of Office dev is solely confined to the world of VBA macros be prepared to be very surprised - the story changes ever so slightly.. okay... hugely with Visual Studio Tools for Office (VSTO to its pals) and even hugelier (?) for the version that'll arrive very soon with Whidbey. Even the story for managed code with the less-than-current versions of Office is much richer than you might expect.

The Office products are of course COM servers, and there's a plethora of techniques that Andrew's book describes for integrating managed code, crossing the managed/unmanaged boundary safely and easily. By sharp contrast with many developer books, it's extremely well written and has a fantastically even pace - never trivialising and never bewildering. The examples (available online) are plentiful, rich, and well documented, so all in all the best £23 I've spent in a while. No, I'm not on commission, and no, we're not related - I just felt that everyone should know about a very sound dev text book!

The book's called .NET Development for Microsoft Office by Andrew Whitechapel, published by MS Press, ISBN 0735621322.

Enjoy!

I've been out of the blogosphere for a little while, partly because I've had my nose buried in some very good books. At the European Games Developers’ Conference last September I realised how little I knew about some of the key areas of gaming technology, and resolved to address the issue not only by buying books (my normal strategy) but also by reading them too.

 

After an excellent session about AI in games, I went to the exhibition book stall and invested in a copy of Nils Nilsson's "Artificial Intelligence: A New Synthesis", (Morgan Kaufmann, ISBN 1 55860 535 5) which I thoroughly enjoyed reading (back then when we still had sunshine). In conversation at the event, I realised I was some kind of alien – fancy not knowing what an A-Star search is – but now I do know and can spout forth at the slightest provocation, which may explain why my social life has dwindled. If anyone can point me to other digestible books about AI I’d be very grateful to hear, besides which life as a hermit quite suits me.

 

In games, as they say, vehicles are the new black. What do we need to make vehicles fun? Good physics engines. I read Engineering at university 25 years ago, and hence can still work out what will happen when two identical inextensible snooker balls collide elastically in a perfect straight line. Tragically the applicability of this crucial calculation is diminished in an Unreal world where I expect to be able to bounce and skid a jeep over a rough snow-covered field at speed, so again I decided that a little revision was in order.

 

My first foray into game physics was via David Bourg’s “Physics for Games Developers” (O’Reilly, ISBN 0 596 00006 5) which is a superb introduction to the principles and maths, and is very well written too.

 

Further research led me to The Book – one of the reviewers said that no games programmer today would use more than 25% of the principles it outlined, so clearly this had to appear on my shelf as well. It’s David Eberly’s “Game Physics” (Morgan Kaufmann, ISBN 1 55860 740 4). My feedback to David would be that it’s a little light on jokes, but it more than makes up for that with its extraordinarily well- and tightly-woven descriptions, equations and code. It’s a superb piece of work, backed up by very portable C++ examples that run over DirectX and OpenGL (putting an abstraction layer over the two of them incidentally – now there’s an idea for a Standards committee to get hold of!) as well as a living web site with yet more descriptive text and code.

 

Suffice to say, I now feel equipped to write code for a world where some objects aren’t round and travelling solely in one dimension.

 

I’m a Microsoft employee, and therefore should tread very carefully around anything that could be construed as a recommendation, particularly where software’s concerned, so I must stress that what I’m about to write in no way constitues a recommendation by the Microsoft corporate body, it doesn’t point to any commercial or other relationship with or endorsement of the vendor, it doesn’t suggest that other vendors and Microsoft are or aren’t doing this stuff… you get the idea – this is purely personal, okay? I just liked it. Right, here we go. If you’ve any doubt that physics is going to be very big in gaming (and I suspect all other UI too) you need to take a look at Novodex’s Rocket demo (http://www.novodex.com/). Top tips – you can pick up pretty much anything with the right mouse key (including the rocket) and the space bar fires balls. For all their simplicity, the Jenga games are enormously satisfying!

 

Coming full circle, and with all the same caveats, if you’re interested in AI, the demo’s and white papers on Kynogon’s site (http://www.kynogon.com/) are very thought-provoking.

 

So. Books. Inevitably, I did weaken and buy some graphics texts too. One was the second in editor Wolfgang Engel’s Shader X series – “Shader X2, Shader Programming Tips and Tricks with DirectX 9” (Wordware, ISBN 1 55622 988 7). Excellent reading and inspirational, it draws together a series of articles that show how to do jolly clever things with the High Level Shader Language, amongst them an article by Microsoft’s own Peter-Pike Sloan. I mention Peter-Pike particularly because he presented (very well I should add) at the GDC and made an impression on me for two reasons: one was that he almost certainly has the best job in the world, pushing the boundaries of graphics; the second was that if I ever fall prey to the suspicion that I may be remotely intelligent I think of him and am immediately grounded and reminded of my relative status – picture a unicellular organism and Isaac Newton and guess which one’s me.

 

My final purchase was a book that caught my eye as one of the authors is Joseph Laviola, Jr. of Brown University. Joseph very kindly gave us permission to use some of his code to demonstrate Tablet PC a while ago – he’d written an interactive pen-based tool for teaching maths, which amongst other things takes equations and graphs them. It can interpret a hand-written equation of surprising complexity, and really shows how pen-based input could change the way we work with computers.

 

I digress! The book itself is “3D User Interfaces” by Doug Bowman, Ernst Kruiff, Ivan Poupyrev and Joseph Laviola (Addison Wesley, ISBN 0 201 75867 9). I’ve always been interested in stereo vision and 3D, so it’s great to have a book that outlines the state of the art and weighs up the pro’s and con’s of many different approaches to working with three dimensions. I cling on (sometimes in desperation) to the belief that mainstream computing will eventually wake up to the huge value that sophisticated graphics could add even to traditional applications – every day I see people struggling with two-dimensional spreadsheets, trying to get a grip on multi-dimensional data – when a simple walk-through visualisation could highlight any issues hiding in the data immediately. I’m searching for a pithy phrase along the lines of “A mesh can paint a thousand spreadsheets” – if you’re feeling creative (and/or pithy) do help me out.

 

So is this all I’ve read since September? Actually no – there’s one more technical book I want to rave about, but that’s on a different theme, so more of that later!

I know, I know - it' s been keeping you awake too... I've no desire to enhance my well-deserved reputation for being interested in things that could induce narcolepsy in an insomniac, but it took me a fair few hours to get to the bottom of how DirectX manages matrices internally, so in case it's bothering you too, below are the fruits of my labour. Why, you may ask, do I care? Imagine you have an application that allows the user to manipulate objects in 3D, for example applying rotations to them. In your interface, you want to display the current state of play. Your user has applied a number of rotations one after another, perhaps by setting rotations about X, Y & Z, and you want to echo the accumulated effect - you need to be able to turn multiple concatenated rotations into a single set of three rotations about those three axes. In short, you want to unpick the resultant matrix - if I do all these X, Y, Z rotations one after another, what one X,Y,Z rotation would have got me to the same place? Managed DirectX gives us a RollPitchYaw matrix, which, it turns out, builds a matrix which could be represented as Rotation(Z) * Rotation(X) * Rotation(Y). The geometry you remember from school (yeh, right) will remind you that Rotation about X by x radians is:

1	0	0
0	Cos(x)	Sin(x)
0	-Sin(x)	Cos(x)

while rotation about Y is

Cos(y)	0	-Sin(y)
0	1	0
Sin(y)	0	Cos(y)

and about Z:

Cos(z)	Sin(z)	0
-Sin(z)	Cos(z)	0
0	0	1

so the DirectX Yaw Pitch Roll calculation (z * x * y) looks like this:

Cos(z).Cos(y) + Sin(z).Sin(x).Sin(y)	Sin(z).Cos(x)	Cos(z).-Sin(y) + Sin(z).Sin(x).Cos(y)
-Sin(z).Cos(y) + Cos(z).Sin(x).Sin(y)	Cos(z).Cos(x)	Sin(z).Sin(y) + Cos(z).Sin(x).Cos(y)
Cos(x).Sin(y)	-Sin(x)	Cos(x).Cos(y)

Hence the C# code below for Managed DirectX will allow us to look at a rotation matrix and get back to one set of YawPitchRoll angles that would give rise to it. The DirectX Matrix structure exposes elements called Mij (e.g. M32, M21 etc.) where the first digit is the row, and the second the column (remember "Rock Cakes" for row followed by column). This being maths there are gotcha's - when the cosine of the pitch angle gets small, (for a pitch of 90-ish degrees, say) numerically things go bananas, so you can take an arbitrary decision about the yaw angle (here I've set it to zero) and deduce a roll. This is okay except where numerical consistency is important (flying jet fighters. guiding satellites and so on) where you can't just swizzle your object in space to make the sums work. If you're looking for the "proper" way to do this, I can recommend a piece I stumbled on called The Right Way to Calculate Stuff by Don Hatch. If you want the code and layout for the XYZ equivalent, holler - I'll be interested to see whether anyone out there got this far before sleep overwhelmed them.

static public void DecomposeRollPitchYawZXYMatrix(Matrix mx, out double xPitch, out double yYaw, out double zRoll)

{

   xPitch = Math.Asin(-mx.M32);

   double threshold = 0.001; // Hardcoded constant - burn him, he's a witch

   double test = Math.Cos(xPitch);

   if(test > threshold) {

      zRoll = Math.Atan2(mx.M12, mx.M22);

      yYaw = Math.Atan2(mx.M31, mx.M33);

   }

   else {

      zRoll = Math.Atan2(-mx.M21, mx.M11);

      yYaw = 0.0;

   }

}

Thanks for your patience, O blogosphere - will try to be less turgid in future.