MikePelton's WebLog : DirectX

DirectX Matrix Multiply

MikePelton — Sat, 06 Aug 2005 17:11:00 GMT

Just in case it's driving you nuts too, I've just rediscovered something. I'd be happy to be proved wrong, but I've been drawing pictures of axes for an hour now (sad, I know), and I'm satisfied I'm right.

You might imagine that...

Matrix m1 = ...

Matrix m2 = ...

Matrix m3 = m1 * m2;

...(I should add in C#) would give you a matrix m3 which represents the results of m1's operations FOLLOWED BY m2's. But no; it's the OPPOSITE, m2 followed by m1.

To say this is counter-intuitive is a massive understatement, and of course if it gets changed 3D worlds everywhere will turn inside out or disintegrate, so live with it we must. I say rediscovered because I remember falling down this same hole a couple of years ago.

There's probably a reasoned argument as to why it's done this way. and I seem to recall GDI+'s matrices do the same thing. Equally I also seem to recall that quaternions in C++ do the opposite; q1 * q2 is q1 followed by q2. So my top tip is next time things look wrong after a matrix calculation, flip the multiplication order and maybe all will be well without you having to write "X", "Y" and "Z" on the edges of a CD cover and invest an hour of your day experiencing the feeling that you may be going mad!

Games Programmers - While Away These Long Winter Nights

MikePelton — Fri, 28 Jan 2005 22:49:00 GMT

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!

Matrix Mysteries II: The XYZ Matrix

MikePelton — Mon, 15 Nov 2004 20:14:00 GMT

I know I promised not to be so dull in future, but enough people seem to share my curiosity about what goes on inside DirectX matrices for it to be worth publishing the details of DX's other pre-defined matrix form, the XYZ matrix.

So, if I create rotation matrices for a rotation about X by x radians (and call it Rx), about Y by y, and about Z by z, and multiply them together Rx * Ry * Rz, I wind up with the following:

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

....and if, as before, I want to look at a matrix and work out what single set of x, y, z rotations would get me to the same orientation, the code below will do the trick.

Like the roll-pitch-yaw case, the numbers go loopy when the rotation about Y is an odd multiple of ninety degrees, so there's a crude test in there to spot that happening and go to a plan B.

(Same disqualifier too - if you're concerned for numerical stability and being able to guarantee getting the same matrix back that you started with, there is a more reliable route which avoids the setting of the angle about z to being zero ["gimbal lock"] and again I'd point you to The Right Way to Calculate Stuff by Don Hatch).

static public void DecomposeXYZRotationMatrix(Matrix mx, out double rx, out double ry, out double rz)
{
   ry = Math.Asin(-mx.M13);
   double threshold = 0.001;
   if(Math.Cos(ry) > threshold)
   {
      rx = Math.Atan2(mx.M23, mx.M33);
      rz = Math.Atan2(mx.M12, mx.M11);
   }
   else
   {
      rx = Math.Atan2(mx.M21, mx.M22);
      rz = 0.0;
   }
}

My next blog will be about Managed DirectX and the Effects framework, so if you think that's dull too, apologies!!

The Mysteries of the DirectX Roll Pitch Yaw Matrix

MikePelton — Fri, 29 Oct 2004 13:32:00 GMT

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.