Every frame of every game is a small avalanche of mathematics. A character turns, a camera swings, sunlight bounces off a wet street, a bullet checks whether it hit — and all of it is vectors, matrices and a few beautiful tricks, run millions of times a second. This course is the maths a game or graphics engine actually runs on, built from the ground up.

It leans hard on linear algebra — a 3-D point is a vector, an object's pose is a matrix, lighting is a dot product — and pays it back by making it move: you'll watch every idea spin, project and render on screen.

The shape of the journey

Seven stages, from a single arrow to a full ray-traced frame.

• Stage 1 — Foundations. Points, vectors, the cross product, normals and planes — the alphabet of 3-D space.
• Stage 2 — Transforms. Translation, rotation and scale stacked into the model matrix, and the scene-graph hierarchy that poses a whole world.
• Stage 3 — Rotations & quaternions. From Euler angles and gimbal lock to the quaternions every engine uses to turn things smoothly.
• Stage 4 — Camera & projection. The view and projection matrices that flatten a 3-D world onto your 2-D screen.
• Stage 5 — Raytracing & lighting. Shooting rays at spheres and triangles, and the equations that make surfaces glow, reflect and refract.
• Stage 6 — Collision & geometry. Bounding volumes, the separating-axis theorem and picking — how a game knows what touched what.
• Stage 7 — Curves & interpolation. Lerp, easing, Bézier curves and splines — the maths of smooth motion and procedural shape.

Stage 1 — Foundations

The alphabet: points and vectors in 3-D, the two products (dot and cross), normals and planes.

1. Points and Vectors
2. Coordinate Spaces and Handedness
3. The Dot Product in Games
4. The Cross Product and Normals
5. The Plane Equation
6. Distance and Direction

Stage 2 — Transforms

Pose an object in the world: translate, rotate, scale — composed into one matrix, and nested into a hierarchy.

1. Translation, Rotation, Scale
2. Homogeneous Coordinates in Practice
3. The Model Matrix
4. Transform Order
5. Transform Hierarchies
6. Inverse Transforms
7. Transforming Normals

Stage 3 — Rotations & quaternions

The hardest, most beautiful corner of game math: how to turn things in 3-D without it all going wrong.

1. Rotating in 2D
2. Complex Numbers as Rotations
3. Rotation Matrices in 3D
4. Euler Angles
5. Gimbal Lock
6. Axis-Angle and Rodrigues' Formula
7. Quaternions
8. Unit Quaternions as Rotations
9. Quaternions and Matrices
10. SLERP

Stage 4 — Camera & projection

Flatten a 3-D world onto a 2-D screen: the view matrix, the projection matrix, and the pipeline that ties them together.

1. The Camera and View Matrix
2. Orthographic Projection
3. Perspective and the Frustum
4. The Perspective Projection Matrix
5. Clip Space and the Perspective Divide
6. The Viewport Transform
7. The MVP Pipeline
8. Depth and the Z-Buffer

Stage 5 — Raytracing & lighting

Render an image by shooting rays into a scene and asking what they hit, then how it's lit.

1. Rays and Parametric Lines
2. Ray-Sphere Intersection
3. Ray-Plane Intersection
4. Ray-Triangle and Barycentric Coordinates
5. Surface Normals and Shading
6. Reflection
7. Refraction
8. The Lighting Equation
9. Recursive Raytracing

Stage 6 — Collision & geometry

How a game knows what touched what: bounding volumes, overlap tests, the separating-axis theorem and picking.

1. Bounding Volumes
2. Overlap Tests
3. Point in Shapes
4. Closest-Point Queries
5. The Separating Axis Theorem
6. Raycasting and Picking
7. Spatial Partitioning

Stage 7 — Curves & interpolation

The maths of smooth motion and procedural shape: lerp, easing, Bézier curves, splines and noise.

1. Lerp and Remap
2. Smoothstep and Easing
3. Bézier Curves
4. Splines
5. Parametric Motion
6. Noise

Let's get started

We begin with the alphabet of 3-D space — the difference between a point and a vector, and why getting that distinction right is the whole game.

Let's get started → Points and Vectors