JohnBolton

There is some misleading (and wrong) information in these replies.

First of all, there is no reason why you can't use the D3DX matrix and matrix functions for OpenGL (though there isn't really a good reason to do it).

Matrices in D3D and OpenGL both functionally have the same layout in memory: X_x,X_y,X_z,X_w,Y_x,Y_y,Y_z,Y_w,Z_x,Z_y,Z_z,Z_w,T_x,T_y,T_z,T_w. X, Y, Z, and T are the basis vectors.

Since there is no difference between D3DX and OpenGL matrices in memory, if you have to use D3DXMatrixTranspose, you are probably doing something wrong.

OpenGL is right-handed and D3D is left-handed, but that is totally irrelevant to matrix operations. Matrix operations give the same result for right-handed and left-handed systems.

What is important is matching the order of operation in OpenGL to the order of the parameters in D3DX. In OpenGL, matrix operations are pre-concatenated. That is, operation M₁ followed by M₂ results in this: v' = M₁M₂v, which is D3DXMatrixMultiply( &M, &M₂, &M₁ ) in D3DX.

Now I will show you an example using your code sample.

T_P = transformation matrix equivalent of glTranslatef(position[0],position[1],position[2])
T_C = transformation matrix equivalent of glTranslatef(centerd[0],centerd[1],centerd[2])
R_A = transformation matrix equivalent of glRotatef(rotateAngle,axis[0],axis[1],axis[2])
R_S = transformation matrix equivalent of glRotatef(ScaleRotateAngle,Saxis[0],Saxis[1],Saxis[2])
S = transformation matrix equivalent of glScalef(scalef[0],scalef[1],scalef[2])
R_S^-1 = transformation matrix equivalent of glRotatef(0-ScaleRotateAngle,Saxis[0],Saxis[1],Saxis[2])
T_C^-1 = transformation matrix equivalent of glTranslatef(0-centerd[0],0-centerd[1],0-centerd[2])

If you expressed that code in column-major notation (used by OpenGL), you get this:

v' = T_PT_CR_AR_SSR_S^-1T_C^-1v

The row-major (used by D3D) equivalent is this:

v' = vT_C^-1R_S^-1SR_SR_AT_CT_P

The D3DX code equivalent is this:

D3DXTranslation( &TCI, -centerd );
D3DXRotationAxis( &RSI, Saxis, -ScaleRotateAngle );
D3DXScaling( &S, scalef );
D3DXRotationAxis( &RS, Saxis, ScaleRotateAngle );
D3DXRotationAxis( &RA, axis, rotateAngle );
D3DXTranslation( &TC, centerd );
D3DXTranslation( &TP, position );

D3DXMatrixIdentity( &M );
D3DXMatrixMultiply( &M, &TP, &M );
D3DXMatrixMultiply( &M, &TC, &M );
D3DXMatrixMultiply( &M, &RA, &M );
D3DXMatrixMultiply( &M, &RS, &M );
D3DXMatrixMultiply( &M, &S, &M );
D3DXMatrixMultiply( &M, &RSI, &M );
D3DXMatrixMultiply( &M, &TCI, &M ); 
glLoadMatrixf( &M );

... or ...

D3DXMatrixIdentity( &M );
D3DXMatrixMultiply( &M, &M, &TCI );
D3DXMatrixMultiply( &M, &M, &RSI );
D3DXMatrixMultiply( &M, &M, &S );
D3DXMatrixMultiply( &M, &M, &RS );
D3DXMatrixMultiply( &M, &M, &RA );
D3DXMatrixMultiply( &M, &M, &TC );
D3DXMatrixMultiply( &M, &M, &TP );
glLoadMatrixf( &M );

Notice how the order of the first D3DX implementation is exactly the same as in the OpenGL code. Notice how the difference in order between the two D3DX implementations simply depends on the order of the parameters. Notice how the values for tranlation, rotation and scale are the same.

[Edited by - JohnBolton on December 14, 2004 10:16:28 PM]