Matrix Multiplication: Vectors and Matrices

Introduction to Matrices

From your chemical engineering studies, you have likely encountered matrices as a way to represent and solve systems of linear equations. In 3D graphics, we use them for a different but related purpose: to represent geometric transformations.

A matrix is simply a rectangular grid of numbers, arranged in rows and columns. A matrix with m rows and n columns is called an m x n matrix.

Matrix-Vector Multiplication: Transforming a Point

The first essential operation is multiplying a matrix by a vector. This is the mechanism we use to apply a transformation to a point or a direction in space. For example, if we have a matrix that represents a 45-degree rotation, multiplying a vector by this matrix will produce a new vector that is rotated by 45 degrees.

Let's start with the intuition behind this.

Now for the mechanics. A vector can be thought of as a matrix with only one column. For a multiplication to be valid, the number of columns in the matrix must equal the number of rows in the vector (which is its number of components).

The calculation itself is a series of dot products. To find the first component of the resulting vector, you take the dot product of the first row of the matrix and the vector. For the second component, you use the second row, and so on.

Let's formalize this with another reading.

Matrix-Matrix Multiplication: Combining Transformations

The real power of matrices comes from the ability to multiply them together. If you have a matrix for rotation (R) and a matrix for scaling (S), you can multiply them to get a single matrix (M = R * S) that performs both rotation and scaling in one operation. This is incredibly efficient for a game engine.

The Golden Rule of Matrix Multiplication
You can only multiply two matrices, A and B, if the number of columns in matrix A is equal to the number of rows in matrix B.

If A is an m x n matrix and B is an n x p matrix, their product C = A * B will be an m x p matrix.

The calculation is an extension of what we just learned. To find the element in row i and column j of the result matrix C, you compute the dot product of row i from matrix A and column j from matrix B.

Key Properties of Matrix Multiplication

There are two crucial properties you must remember:

1. It is NOT commutative: A * B ≠ B * A. The order in which you multiply matrices matters immensely. Applying a rotation and then a translation is not the same as applying a translation and then a rotation. You should read transformations from right to left: in the expression M = T * R * v, the vector v is first rotated (R), and the result is then translated (T).

2. It IS associative: (A * B) * C = A * (B * C). This is what allows us to pre-calculate a combined transformation matrix (M = A * B) and then apply it to many vectors, which is a fundamental optimization in graphics.

Row vs. Column Vectors: An Important Convention

You will find that some math books and graphics APIs (like DirectX) write matrix-vector multiplication as v' = v * M, where v is a row vector. Others (like OpenGL, which we will use) write v' = M * v, where v is a column vector.

This choice affects how the matrices themselves are written (one is the transpose of the other) and the order in which you multiply them to combine transformations.

• Row Vector Convention (v * M): Transformations are applied left-to-right. v' = v * S * R * T means scale, then rotate, then translate.
• Column Vector Convention (M * v): Transformations are applied right-to-left. v' = T * R * S * v means scale, then rotate, then translate.

This is a frequent source of bugs for developers. Since our goal is to build an engine that will eventually interface with OpenGL, we will primarily use the column vector convention.

From Math to Code

Understanding the algorithm is key to implementing it yourself. Let's look at how the row-by-column multiplication logic translates into code.

Practice

Let's try a simple 2x2 matrix multiplication by hand. Given:
$A=\left[\begin{array}{cc}3& -1\\ 2& 4\end{array}\right],B=\left[\begin{array}{cc}5& 0\\ -2& 7\end{array}\right]$

Calculate C = A * B.

For more practice, you can attempt the problems in Exercise 4 of the "3D Math Primer" reading.

Conclusion

You've now learned the essential mechanics of matrix multiplication, a cornerstone of 3D graphics. While you'll eventually use a library like GLM to handle these calculations in C++, understanding the underlying algorithm is crucial for debugging and for building your engine from the ground up.

Key Takeaways:

• A matrix is a grid of numbers used to represent transformations.
• Matrix-vector multiplication (M * v) applies a transformation to a point. The result is a new, transformed vector.
• Matrix-matrix multiplication (A * B) combines two transformations into a single new one.
• For multiplication to be valid, the number of columns in the first matrix must equal the number of rows in the second.
• The order of multiplication is critical: A * B is not the same as B * A.

In our next lesson, we will put this knowledge to use. We will stop focusing on the how of multiplication and start exploring the what—we will construct the specific matrices used for identity, translation, scaling, and rotation.