The GLM Library

In the previous lesson , we learned that to perform transformations like translation, rotation, and scaling, we need matrices. GLM provides these types:

• glm::mat3: A 3x3 matrix (Used for 2D transformations with homogeneous coordinates)
• glm::mat4: A 4x4 matrix (Used for 3D transformations with homogeneous coordinates)

The Identity Matrix

When we construct a matrix in GLM with a single scalar value (usually 1.0f), it creates an Identity Matrix.

1glm::mat3 Identity{1.0f};

An identity matrix has 1s along the main diagonal and 0s everywhere else.

They key property of an identity matrix is that, when we multiply a vector by it, the vector doesn't change.

Conceptually, this means that, when used as a transformation, the identity matrix performs no transformation at all. This means it is effectively a blank canvas that serves as a starting point for our transformation pipeline. We start with an identity matrix, and we then apply our required transformations to it.

Below, we create an identity matrix, and we'll learn how to add transformations later:

1#include <iostream>
2#include <glm/glm.hpp>
3
4#define GLM_ENABLE_EXPERIMENTAL
5#include <glm/gtx/string_cast.hpp>
6
7int main(int argc, char** argv) {
8  // Create a 3x3 Identity Matrix
9  glm::mat3 Identity{1.0f};
10
11  std::cout << "Identity Matrix:\n"
12    << glm::to_string(Identity) << "\n";
13
14  return 0;
15}

1Identity Matrix:
2mat3x3((1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0))

One of the most confusing aspects of working with matrices can be the matrix memory layout.

In mathematics, we typically write matrices in row-major order. We read them left-to-right, top-to-bottom.

However, many systems represent and store matrices in column-major order. This is particularly common in graphics APIs, including GLM.

This is something we need to be mindful of when creating or manipulating matrices manually, and also when we use them to apply transformations which we'll cover soon.

When we access elements using the subscript operator [], the first index is the column, and the second index is the row.

1#include <iostream>
2#include <glm/glm.hpp>
3
4#define GLM_ENABLE_EXPERIMENTAL
5#include <glm/gtx/string_cast.hpp>
6
7int main(int argc, char** argv) {
8  glm::mat3 MyMatrix(1.0f);
9
10  MyMatrix[0][0] = 1; // Column 0, Row 0
11  MyMatrix[1][0] = 2; // Column 1, Row 0
12  MyMatrix[2][0] = 3; // Column 2, Row 0
13
14  MyMatrix[0][1] = 4; // Column 0, Row 1
15  MyMatrix[1][1] = 5; // Column 1, Row 1
16  MyMatrix[2][1] = 6; // Column 2, Row 1
17
18  MyMatrix[0][2] = 7; // Column 0, Row 2
19  MyMatrix[1][2] = 8; // Column 1, Row 2
20  MyMatrix[2][2] = 9; // Column 2, Row 2
21
22  std::cout << "Col 1: "
23    << glm::to_string(MyMatrix[0]);
24
25  return 0;
26}

1Col 1:vec3(1.0, 4.0, 7.0)

If we construct a mat3 manually, the arguments fill the first column, then the second, and so on. If we stringify the full matrix using glm::to_string(), our string is also formatted in column-major order. That is, as a list of column vectors:

1#include <iostream>
2#include <glm/glm.hpp>
3
4#define GLM_ENABLE_EXPERIMENTAL
5#include <glm/gtx/string_cast.hpp>
6
7int main(int argc, char** argv) {
8  // Constructing a matrix manually.
9  // We provide arguments COLUMN by COLUMN.
10  glm::mat3 MyMatrix{
11    1.f, 4.f, 7.f,  // Column 0
12    2.f, 5.f, 8.f,  // Column 1
13    3.f, 6.f, 9.f,  // Column 2
14  };
15
16  std::cout << glm::to_string(MyMatrix);
17
18  return 0;
19}

1mat3x3((1.0, 4.0, 7.0), (2.0, 5.0, 8.0), (3.0, 6.0, 9.0))

Transposing Matrices

We can convert row-major matrices to column-major matricies (and vice versa) via transposation.

Transposing flips the matrix over its diagonal, converting rows into columns and vice-versa.

GLM provides the glm::transpose() function for this purpose.

1#include <iostream>
2#include <glm/glm.hpp>
3
4#define GLM_ENABLE_EXPERIMENTAL
5#include <glm/gtx/string_cast.hpp>
6
7int main(int argc, char** argv) {
8  // If we load this into GLM, it interprets it as columns
9  glm::mat3 RowMajor{
10    1.f, 2.f, 3.f,
11    4.f, 5.f, 6.f,
12    7.f, 8.f, 9.f
13  };
14
15  // Transpose it to fix the layout for GLM
16  glm::mat3 ColMajor{glm::transpose(RowMajor)};
17
18  std::cout << "Original:\n"
19    << glm::to_string(RowMajor) << "\n";
20  std::cout << "Transpose:\n"
21    << glm::to_string(ColMajor);
22
23  return 0;
24}

1Original:
2mat3x3((1.0, 2.0, 3.0), (4.0, 5.0, 6.0), (7.0, 8.0, 9.0))
3Transpose:
4mat3x3((1.0, 4.0, 7.0), (2.0, 5.0, 8.0), (3.0, 6.0, 9.0))

In mathematical writing, the transpose operation is represented by a superscript $T$:

Transposing Vectors

Transposing a row vector converts it to a column vector, and vice versa:

Vector transposition is rarely required in code, but it is often used in papers and textbooks to present column vectors horizontally for stylistic reasons. This is because a horizontal style like $\begin{bmatrix} x & y & z & w \end{bmatrix}^T$ flows organically within a line of text.

The equivalent vertical presentation $\begin{bmatrix} x \\ y \\ z \\ w \end{bmatrix}$ requires unnatural spacing.

As we covered previously, the reason we define translations using matrices is that it allows us matrix multiplication to apply those transformations. That is, we can transform a vector by multiplying it with a matrix.

Unlike regular multiplication, matrix multiplication is not commutitive. That is, $AB$ and $BA$ are not equivalent if $A$ and $B$ are matrices.

When we want to transform a column vector by a column-major matrix, the matrix goes on the left, and the vector goes on the right.

In a row-major system, we'd do the exact opposite. Our vector would be represented as a row, and would be the left operand, with the transformation matrix on the right.

Practical Example

Let's look at a practical example, within GLM's column-major system. We will manually construct a matrix that translates objects by (50, 100) and use it to transform a position vector and direction vector.

Given we're using a 3x3 matrix to represent our transformations, we now need to add the homogenous coordinate to our vectors. This third component is typically called $w$ in a 2D system, although if we ever need to directly access it within the glm::vec3 type, it is stored in the member variable called z.

1#include <glm/glm.hpp>
2
3int main(int argc, char** argv) {
4  glm::vec3 Position{8.f, 5.f, 1.f};
5
6  float x{Position.x}; // 8.0
7  float y{Position.y}; // 5.0
8  float w{Position.z}; // 1.0 
9
10  return 0;
11}

For the position, we set this third component to 1.0f, which indicates that this vector should be affected by translation.

For velocity, or any other vector that represents a relative effect, we set w to 0.0f.

We create this transformation matrix manually in the following example, but it's not necessary to understand why this specific matrix represents a translation. We'll cover transformations and how to define them in a more intuitive way in the next lesson.

1#include <iostream>
2#include <glm/glm.hpp>
3
4#define GLM_ENABLE_EXPERIMENTAL
5#include <glm/gtx/string_cast.hpp>
6
7int main(int argc, char** argv) {
8  // A position at (10, 10)
9  // w = 1 means it will be affected by translations
10  glm::vec3 Position{10.f, 10.f, 1.f};
11  
12  // A velocity of (5, 2)
13  // w = 0 means this vector represents a
14  // relative value, and should not be translated
15  glm::vec3 Velocity{5.f, 2.f, 0.f};
16
17  // A matrix that translates by (50, 100)
18  // Constructed manually using column-major order
19  glm::mat3 Translation{
20    1.0f, 0.0f, 0.0f,   // Col 0
21    0.0f, 1.0f, 0.0f,   // Col 1
22    50.0f, 100.0f, 1.0f // Col 2
23  };
24
25  // Apply the transformation
26  // Important: The matrix is the LEFT operand
27  // and the vector is the RIGHT
28  glm::vec3 NewPosition{Translation * Position};
29
30  std::cout << "Old Position: "
31    << glm::to_string(Position) << "\n";
32  std::cout << "New Position: "
33    << glm::to_string(NewPosition) << "\n";
34    
35  // Transform the velocity
36  glm::vec3 NewVelocity{Translation * Velocity};
37
38  std::cout << "Old Velocity: "
39    << glm::to_string(Velocity) << "\n";
40  std::cout << "New Velocity: "
41    << glm::to_string(NewVelocity) << "\n";
42
43  return 0;
44}

1Old Position: vec3(10.0, 10.0, 1.0)
2New Position: vec3(60.0, 110.0, 1.0)
3Old Velocity: vec3(5.0, 2.0, 0.0)
4New Velocity: vec3(5.0, 2.0, 0.0)

The position has successfully moved by (50, 100), whilst the velocity remained the same at (5, 2).

In this lesson, we integrated the GLM library into our project and learned its fundamental syntax.

• Installation: We used CMake's FetchContent to download and link the header-only GLM library.
• Vectors: glm::vec2, vec3, and vec4 behave similarly to our custom structs but come with built-in arithmetic and utility functions.
• Matrices: glm::mat4 is the standard type for 3D transformations, and glm::mat3 for 2D transformations. We generally start by constructing an identity matrix.
• Column-Major Order: GLM stores matrices by column. We must access them as matrix[column][row], and we pass constructor arguments column-by-column. glm::transpose() can swap rows and columns if needed.
• Transformation: We transform vectors by multiplying them with a matrix: Matrix * Vector.

In the next lesson, we will stop constructing matrices manually. We will use GLM's powerful helper functions to generate Translation, Rotation, and Scale matrices automatically, and use them to implement the Scene/Camera transformation pipeline we designed previously.