✓ Free online edition

Learning C++ by Building Games: Fundamentals

The core math and algorithms behind every game, built from scratch in C++ — from a single point on the screen to a textured 3D scene. The complete second edition, free to read online.

35 Chapters 36 Demos C++ SDL 3

Start at Chapter 1 → Get the code on GitHub → Get the ebook & paperback →

Reading online is completely free — browse the contents below and start anywhere. Prefer it on your shelf or your Kindle? It's on Amazon too.

35chapters, free online

36runnable demos you build

187diagrams & screenshots

£0no sign-up, no paywall

A few screens from the book — the demos you'll build, each one a program you run and drag around.

A steering-behaviours demo — little triangle agents leaving coloured trails as they seek, pursue, wander and graze. — Steering behaviours — seek, arrive, pursue, wander.

A physics demo — a pile of coloured balls settled at the bottom of the window, one thrown in mid-air. — A small physics engine, settling a pile of bodies.

An A-star pathfinding demo — a grid with explored cells and the found path highlighted from a green start to a red goal. — Pathfinding, worked all the way up to A*.

A textured, perspective-correct 3D cube rendered by the book's own software rasterizer. — A textured 3D cube — every pixel your own code.

Behind every game is a quiet layer of mathematics doing the real work — a dot product that slides a character along a wall, a matrix that makes a distant tower grow as you fly toward it, a graph search that finds the way around a maze. This book is that layer, built from scratch in C++: vectors and trigonometry, motion and geometry, collision and physics, pathfinding and rendering, all the way to a textured 3D scene you can turn, fly through and texture yourself. There are no games to finish here — instead every idea gets a focused demo of its own, 36 in all, each a program you run, drag around and watch behave. SDL 3 opens the window and draws; every transform, intersection and step of physics is your own code. The whole second edition is free to read online.

What you'll build

The Vec2 type Dot & cross products Steering behaviours Bezier curves The separating axis theorem Swept collision A physics engine A* pathfinding Randomness & noise A 2D camera A textured 3D cube Quaternions

Contents

Thirty-five chapters in seven parts and six appendices, every one free to read online — each chapter a focused demo you build and run. Start at the beginning, or jump to whatever you want to see first.

Start here

Why the hidden math matters, how the demos work, and how to get the most from the book.

—PrefaceWhat the book teaches, who it's for, and the four ideas that shape every chapter.

Part 1 — Foundations: The Vector

Coordinates and the skeleton, the Vec2 type and its arithmetic, and the dot and cross products.

1Setting the Scene: Coordinates, Points & Our SDL ToolkitScreen coordinates, points, and the small "skeleton" program every demo grows from. 2The 2D Vector, and Building Vec2What a vector is, and building the Vec2 type — with operator overloading — from scratch. 3Vector Arithmetic: Length, Distance & DirectionLength, distance and direction — the everyday arithmetic of vectors. 4The Dot and Cross ProductsThe two products that answer "which way?" and "how aligned?" — the workhorses of game math.

Part 2 — Angles, Rotation and Motion

Trigonometry and rotation, motion by delta time and easing, then steering and the forces of nature.

5Angles, the Unit Circle & TrigonometryAngles, the unit circle, sine and cosine — turning directions into numbers. 6Rotating Points and VectorsRotate a point or a vector around any centre, by any angle. 7Motion: Delta Time, Velocity & AccelerationMove things smoothly at any frame rate with velocity, acceleration and delta time. 8Interpolation and EasingBlend between values, and shape motion with easing curves. 9Steering BehaviorsSeek, arrive, pursue, flee and wander — agents that move like they mean it. 10Forces of Nature: Gravity, Friction & BouncingGravity, friction and bouncing, as forces you add up each frame.

Part 3 — Geometry, Shapes and Curves

Shapes and lines, distances and closest points, and Bezier curves and splines.

11Shapes and How We Represent ThemCircles, rectangles and polygons, and how to store them. 12Lines, Rays, and DistancesLines, rays and segments, and the distances between them. 13Closest PointsFind the closest point on a line, segment or shape — the basis of so much collision. 14Curves and Paths: Bezier and SplinesBezier curves and splines — smooth paths things can follow.

Part 4 — Collision Detection and Response

Overlap tests and the separating axis theorem, raycasting and swept tests, and collision response.

15Point and Overlap TestsIs the point inside? Do these two shapes overlap? The core yes/no tests. 16The Separating Axis TheoremOne elegant idea that tests any two convex polygons for overlap. 17Raycasting and Swept CollisionCast a ray, and catch fast movers before they tunnel through walls. 18Collision ResponseWhat happens after a hit: stop, slide along the wall, or bounce.

Part 5 — Scaling Up

Spatial partitioning and a small physics engine, randomness and noise, and pathfinding up to A*.

19Spatial Partitioning: Grids and QuadtreesGrids and quadtrees, so you test only the pairs that could collide. 20A Simple Physics Engine: Mass, Forces & the Fixed TimestepTie it together: mass, forces, impulses and a stable fixed timestep. 21Randomness and NoiseRandom numbers you can trust, and smooth noise for natural-looking variety. 22Pathfinding I: Grids, BFS and DijkstraFind a way through a grid with breadth-first search and Dijkstra. 23Pathfinding II: A* and BeyondA* and its heuristics — the pathfinding every game reaches for.

Part 6 — Rendering in 2D

Textures, the scene graph and 2D matrices, and the camera.

24Textures and UV MappingDraw textures, and map them onto shapes with UV coordinates. 25Transforms and the Scene GraphParent transforms to children so whole scenes move together. 26Matrices for 2DFold translate, rotate and scale into one 2D matrix. 27The 2D CameraA camera that pans, zooms and rotates the world around the player.

Part 7 — Into the Third Dimension

3D vectors and matrices, projection and the camera, the full pipeline — then hidden surfaces, texturing and quaternions.

28Thinking in 3D: Coordinates and VectorsAdd a third axis — 3D coordinates and vectors, and what changes. 293D Transforms and 4×4 MatricesTranslate, rotate and scale in 3D with 4×4 matrices. 30Projection: From 3D to a 2D ScreenProject a 3D world onto a flat screen, the way a camera does. 31The 3D Camera: View Matrix and Look-AtPoint a camera anywhere in 3D with a view matrix and look-at. 32The Full Pipeline and Wireframe RenderingPut it together into a pipeline that draws a wireframe model. 33Hidden Surfaces: Culling, Sorting & the Z-BufferDraw solids correctly — back-face culling, sorting and the z-buffer. 34Texturing in 3DTexture those 3D surfaces, with perspective-correct mapping. 35Rotations Done Right: QuaternionsQuaternions — smooth 3D rotation without the gimbal-lock traps.

Appendices

Reference, the skeleton in full, and setup for other platforms.

AMath Cheat SheetEvery formula the book uses, gathered on one page. BThe Demo SkeletonThe small program every demo starts from, printed whole. CSDL3 Quick ReferenceThe SDL 3 functions the demos call, in one place. DWhere to Go NextWhere to take these ideas next, and where they came from. EGlossaryEvery term the book teaches, defined in one place. FFor Mac & Linux UsersBuild every demo on macOS or Linux with CMake and VS Code.

Every demo is on GitHub. The complete, ready-to-run project for each of the 36 demos lives at EliteIntegrity/Learning-C-by-Building-Games-Fundamentals-2nd-Edition — one folder per demo, with SDL bundled so each opens and runs as it comes. View repo →

Learning C++ by Building Games: Fundamentals

What you'll build

Part of the series

Learning C++ by Building Games →

Using C++ to Build a Traditional Roguelike →

Building C++ Games with AI →