The Open Inventor API uses the convention that positions and directions in 3D space are represented by row vectors. Therefore, to apply a transform matrix, the vector is post-multiplied by the matrix as shown in the following figure. Many mathematics and computer graphics books use column vector notation, however there is no functional difference between these two approaches.

Note that the commonly used terms "row major" and "column major" refer to the storage order of the matrix components in memory. This has nothing to do with how you use matrices and vectors with the Open Inventor API. Internally Open Inventor uses the same storage order as OpenGL to allow matrices to be passed efficiently to/from the GPU. When using the Open Inventor API just remember that positions are row vectors, as shown here.

[X' Y' Z' 1] = [X Y Z 1] * | m11 m12 m13 m14 |
                           | m21 m22 m23 m24 |
                           | m31 m32 m33 m34 |
                           | m41 m42 m43 m44 |

Some common 4x4 transform matrices look like this:

Identity  | 1 0 0 0 |  Translate  | 1  0  0  0 |  Scale  | Sx  0  0  0 |  RotateX  | 1    0     0 0 |
          | 0 1 0 0 |             | 0  1  0  0 |         |  0 Sy  0  0 |           | 0 cosT -sinT 0 |
          | 0 0 1 0 |             | 0  0  1  0 |         |  0  0 Sz  0 |           | 0 sinT  cosT 0 |
          | 0 0 0 1 |             | Tx Ty Tz 1 |         |  0  0  0  1 |           | 0    0     0 1 |

Therefore, to create a translation matrix you could initialize the SbMatrix object like this (or you could simply use the SetTranslate() convenience method):

SbMatrix( 1,0,0,0, 0,1,0,0, 0,0,1,0, Tx,Ty,Tz,1 )

For convenience SbMatrix allows its values to be accessed using 2D array syntax, like this:

value = matrix[row,column];

For example, the translation X, Y, Z values in the above example can be retrieved using:

float Tx = matrix[3,0]  // Row 3, Column 0
float Ty = matrix[3,1]  // Row 3, Column 1
float Tz = matrix[3,2]  // Row 3, Column 2

Multiplying points

Points (positions in 3D space) are transformed by post-multiplying the row vector with the transform matrix like this (symbolically):

P' = P * M

If you need to transform a point by a matrix use the MultVecMatrix() method as shown here (initialization of variables not shown):

SbMatrix M ...
SbVec3f  src, dst ...
M.MultVecMatrix( src, dst );

Note that it is safe to use the same SbVec3f object as both src and dst.

In the class SbViewVolume, for example, the ProjectToScreen() method first calls the GetMatrix() method to get the combined model/view/projection matrix, then calls the matrix object's MultVecMatrix() method to transform the 3D point into normalized clipping space (-1 to 1). (It then does one more step to convert that position to 0..1 normalized screen space but that's not important here.)

Multiplying directions

Vectors that represent a direction in 3D space rather than a position, for example surface normal vectors for geometry, can also be transformed. But in this case the translation portion of the matrix (if any) must not be used. For example, if a matrix contains the translation [10, 20, 30], then transforming the normal vector [0, 0, 1] using multVecMatrix() would produce the result [10, 20, 31]. However the correct result is still [0, 0, 1] because translation has no meaning for a direction vector. The method MultDirMatrix() is provided to transform direction vectors ignoring the translation portion of the matrix.

Generally normals should be transformed by the inverse transpose of the matrix as shown here (initialization of variables is not shown). See standard computer graphic references for the explanation.

SbMatrix M ...
SbVec3f  src, dst ...
M.Transpose().Inverse().MultDirMatrix( src, out dst );

Note that if the matrix is orthonormal, i.e. purely rotational with no scaling or shearing, then the inverse transpose is the same as the original matrix and it is not necessary to compute the inverse transpose.

Multiplying matrices

A series of transforms, for example scale, rotate and translate can be combined into a single transform matrix by multiplying the matrices together. The result of such a multiplication is order dependent. Using the row vector convention, we can say that transforms are applied from "left to right". We normally want scaling applied first, then rotation, then translation, as shown here (symbolically):

P' = P * S * R * T

So we would build the combined transform matrix M from scale, rotate and translate matrices S, R and T like this (symbolically):

M = S * R * T

Note that convenience nodes like SoTransform do this (combine the scale, rotate and translate) for you automatically. So you don't necessarily need to remember all the details.

If you need to combine matrices yourself, you can use the MultLeft() or MultRight() method to multiple each matrix with the combined matrix. The name “multLeft” means to pre-multiply the SbMatrix object with the specified SbMatrix parameter, so we would combine the matrices like this (initialization of variables not shown):

SbMatrix M, S, R, T ...
M = T;
M.MultLeft( R );
M.MultLeft( S );

Note that MultLeft() overwrites the matrix currently in the SbMatrix object. So usually (as shown) you will start by making a copy of the first matrix as the starting point for accumulation.

The name “multRight” means to post-multiply the SbMatrix object with the specified SbMatrix parameter. So we would combine the matrices like this (initialization of variables not shown):

SbMatrix M, S, R, T ...
M = S;
M.MultRight( R );
M.MultRight( T );

Note that MultRight() also overwrites the matrix currently in the SbMatrix object. So usually (as shown) you will start by making a copy of the first matrix as the starting point for accumulation.

Reference