# Advanced C++ Programming Tutorial 5

Hot take: the Matrix is a mediocre film at best. It's a pretty great way to encode transformations though, so let's matrix it up!

## Topics

### Part 1

• Matrix form
• Matrix by vector multiplication
• Matrix encoding of scaling, rotation, and flipping
• Matrix multiplication
• Concatenating matrix transforms

### Part 2

• Augmented 3x3 matrix for encoding translations
• Matrix multiplication order matters!
• Porting pipeline to use matrix transforms
• Bug hunting!

## Video Timestamp Index

### Tutorial 5.1

• Matrices: what are they, what are they good for? 0:44
• Basic Matrix operations: Matrix by Vector multiplication 3:05
• Creating a templated `_Mat2<T>` Matrix class 7:16
• Matrix data stored as 2D array `T arr`
• Implementing the Matrix by Vector multiplication method 9:21
• Testing in `game.cpp` 13:00
• Implementing basic transformations in Matrix form as static functions 15:16
• Scaling & Identity Matrices 17:13
• Flipping the y-axis 18:01
• Rotation 18:56
• Testing in `game.cpp` 21:25
• Basic matrix operations: Matrix multiplication 23:06
• Implementing & testing the Matrix multiplication method 25:52
• Recap: concatenating transformations by multiplying transformation matrices 30:10
• This is the beauty of matrix operations: one single concatenated matrix holds all the transformation information
• Concatenating matrices cuts down the number of vector operations needed at runtime

### Tutorial 5.2

• Translation: why is it a complicated transformation? 0:14
• Trick: augment the matrix (add an extra dimension) 3:11
• Coding this into the framweork 6:54
• Implementing a `Mat3` class for (3x3) matrices 6:54
• Implementing a `Vec3` class for (3x1) vectors 8:51
• Test run 10:48
• The order of applying transformations and its relation to Matrix multiplication (concatenation) 12:09
• The order in which you concatenate matrices matters: ABC != CBA
• The sequence of applying transformations reads from right to left in Matrix multiplication
T = CBA means transformation A is applied first, then B, then C
• Demo of this principle in debug mode 14:19
• Matrix augmentation is not just a hack, it falls in the domain of Projective Geometry 15:29
• Fix up the Starfield rendering pipeline 16:31
• Design decision: keep working with `Vec2`, this requires conversion operators to and from `Vec3`
• Refactoring the `DrawClosedPolygon` function in the `Graphics` class 18:03
• Refactoring the `Drawable` class 19:15
• Refactoring the `Entity` class 23:22
• Refactoring the `CoordinateTransformer` class 24:00
• Debugging session: the wrong order of transformations can mess you up 24:51
• Be careful with Matrix multiplication operators: using the overloaded `operator*=()` is risky:
`M *= A` yields M=MA, but we need M=AM
• Recap & key takeaways: math is doable, mind your order of concatenation 32:12
• Tutorial Roadmap from here on out 34:27