Introduction

When you’re making a game engine, you are constantly multiplying and constructing transformation matrices; chances are, you ran by the subject of row/column-major along the way and possibly got confused about some things. In this post, I’d like to make things clear and share with you what I learned when I had the same experience.
Before beginning, please note the following:

  • A matrix A is defined as Matmxn where m=rows n=cols, and a(i, j) always refers to the element in the i-th row and j-th column. So in mathematics, whenever you see row/column indices, the first number should always be the row, and the second number is always the column.

  • Multiplying two matrices is defined if and only if the number of columns in the first matrix is equal to the number of rows in the second matrix, i.e. the inner dimensions must match.

  • In mathematics, there’s no such thing as row/column-major. Row/column-major refers only to storage layout, which is specified by the programming language. What we do have, are row and column vectors.

Row and column vectors

If we have a Mat4x4 transform M and a Vec4 v, and we wanted to transform v by M; we multiply them in one of two ways:

  1. v is a row vector Mat1x4, and transforming v by M is written in the order vM. Doing Mv, i.e. Mat4x4*Mat1x4 is not allowed, because the inner dimensions don’t match.

  2. v is a column vector Mat4x1, and transforming v by M is written in the order Mv.

Take the following two examples (in code form for alignment), where M here is a Mat2x2 and v is a Vec2:

I) Mv:      | x |
            | y |
           *
| m11 m12 | | m11*x + m12*y | 
| m21 m22 | | m21*x + m22*y |


II) vM:     | m11             m12 |  
            | m21             m22 | 
           *
    | x y | | x*m11 + y*m21   x*m12 + y*m22 |

The results are different and that is not surprising; matrix multiplication is not commutative. Getting the same result requires us to transpose both v and M, not just v (as the transpose of a column vector is a row vector and vice versa).

So, row and column vectors tell us the order of multiplication, and therefore, how we should construct our transform matrices. Having said that and to reiterate: if you use a column vector v and have constructed a transform matrix M, you would do Mv to apply the transform. If, for whatever reason, you decided to switch to row vectors, which means you have transposed v; you will no longer get the same output vector, unless you also transpose the transform matrix M. Only then would vM give the same result.

Row- and column-major

Almost everywhere except for early Computer Graphics, column vectors are used by default, i.e. multiplication order in most textbooks is Mv.

From what I’ve read, this annoyed a lot of people and someone decided to fix the OpenGL spec and switch to column vectors instead of row vectors, to be consistent with most math and physics textbooks.

Here is where the col/row-major comes in:
for clarity, I want to define a translation matrix T where the translation vector t in early Computer Graphics was placed in the last row, like so:

T "vM":
|  1  0  0  0 |
|  0  1  0  0 |
|  0  0  1  0 |
| tx ty tz  1 |

Now if we were to define this matrix in C/C++, we would need to consider something: given that computer memory addressing is 1-dimensional, does C/C++ store the entire 2D array contiguously in memory?
If yes, then the language has to decide which elements of that 2D array are going to be contiguous. If rows are contiguous, then it is row-major. If columns are contiguous; it is column-major.
As you may already know, C/C++ does store 2D arrays contiguously in memory, and it is row-major. So if you were to define the matrix T in C/C++; it would look like this in memory:

|| 1, 0, 0, 0,   0, 1, 0, 0,   0, 0, 1, 0,   tx, ty, tz, 1 ||

When they switched to column vectors, T had to change to this:

T "Mv":
|  1  0  0  tx |
|  0  1  0  ty |
|  0  0  1  yz |
|  0  0  0   1 |

If we change T in C/C++; it would now look like this in memory:

|| 1, 0, 0, t.x,   0, 1, 0, t.y,   0, 0, 1, t.z,   0, 0, 0, 1 ||

They didn’t like that they weren’t compatible with the old memory layout, so their “fix” was to change from row-major to column-major. That means if we have a matrix B and make B[j][i] = T[i][j], the columns for B are now stored contiguously in memory. That way B has the old memory layout, only now using column vectors instead of row vectors.

The fact that a matrix is stored in column-major does NOT affect the rules of multiplication, but only how we retrieve some element in that matrix using some programming language.
Remember in mathematics, if we see row/column indices, the first number is always referring to the row, and the second number is referring to the column. M[][] however, is programming language syntax, and whether the first number in that context represents row or column depends on whether M is row-major or column-major.
Take as an example a Mat3x3 C, and a Vec3 v; we want to transform v by C. Let’s say we are using column vectors, so the multiplication order is Cv. The y-component for the resulting vector is computed mathematically as:

c21x + c22y + c23*z

When implementing this in code, only now do we care about row-major vs. column-major. Because for example, how do we retrieve c21 from memory?

// If C is row-major.
result.y = C[2][1]*v.x + C[2][2]*v.y + C[2][3]*v.z;

// If C is column-major.
result.y = C[1][2]*v.x + C[2][2]*v.y + C[3][2]*v.z;

From what I understand, the OpenGL spec went against the mathematical notation for matrix indices, claiming that they use “column-major index notation”, i.e. a(i, j) in their notation is the element in i-th column and j-th row; when in reality, there is no such thing as “column-major” in math, it doesn’t care about storage order, and a(i, j) is always the element in i-th row and j-th column.

Final Remarks

In your engine, you need to specify two things when it comes to matrices and matrix multiplication:

  • row vectors vs. column vectors (to decide order of multiplication).
  • row-major vs. column-major (to decide how to store matrix in memory).

I like using row-major with column vectors, to stay consistent with the common notation of C/C++ and math, but it is important to note that column-major can be a better choice when doing SIMD.

When declaring your matrix structure, a trick you can do is name each element by its index explicitly, where the first number is always the row, as per the mathematical notation:

// row-major.
// Matmxn
// a(i, j) = arr[i][j] = arr[i*m + j]
struct Mat4x4
{
    float _11, _12, _13, _14;
    float _21, _22, _23, _24;
    float _31, _32, _33, _34;
    float _41, _42, _43, _44;
};

// column-major.
// Matmxn
// a(i, j) = arr[j][i] = arr[i + n*j]
struct Mat4x4
{
    float _11, _21, _31, _41;
    float _12, _22, _32, _42;
    float _13, _23, _33, _43;
    float _14, _24, _34, _44;
};

And now in our matrix multiplication function, we use the variable names instead of indexing using M[][]:

Mat4x4 M;
Vec4   v;

// Mv+row-major.
result.x = M._11*v.x + M._12*v.y + M._13*v.z + M._14*v.w;
result.y = M._21*v.x + M._22*v.y + M._23*v.z + M._24*v.w;
result.z = M._31*v.x + M._32*v.y + M._33*v.z + M._34*v.w;
result.w = M._41*v.x + M._42*v.y + M._43*v.z + M._44*v.w;

// Mv+column-major.
result.x = M._11*v.x + M._12*v.y + M._13*v.z + M._14*v.w;
result.y = M._21*v.x + M._22*v.y + M._23*v.z + M._24*v.w;
result.z = M._31*v.x + M._32*v.y + M._33*v.z + M._34*v.w;
result.w = M._41*v.x + M._42*v.y + M._43*v.z + M._44*v.w;

//
//
// No difference!

You also ideally want to use same multiplication order in both CPU and GPU. Nowadays, you can easily tell shader languages, such as GLSL and HLSL, what sort of matrices you want to use.

References

Fabian Giesen’s blog:
Row major vs. column major, row vectors vs. column vectors
Row-major vs. column-major and GL ES

Austin Morlan’s blog:
OpenGL matrices