Course Preview

Game Mathematics

Game mathematics is the vector, trigonometry, matrix, and geometry math that game engines use to position, rotate, move, and collide objects on screen. It is the calculation layer under features like character movement, camera control, aiming, and physics response, expressed through engine types such as vectors, transforms, and quaternions.

itSoftware engineering | OpenSkills.info

Recommended first:game-engine-fundamentals

Course pathWalk it in order

Look it upDip in anytime

Go furtherLeaves this page

Don't Panic: Game Mathematics

Game mathematics is the calculation layer beneath movement, turning, cameras, and collision. It is not a separate engine hiding under the engine. It is the small set of operations that the engine's friendly names eventually ask for anyway. A Vector3 may look reassuringly like a container with a job title, but it still expects you to know whether its numbers describe a position, a direction, or a velocity. Numbers are loyal, but they do not volunteer context.

Coordinate spaces explain why an object can be perfectly correct in local space and spectacularly misplaced in world space. A transform carries position, rotation, and scale so an object's own geometry can join the shared scene. The important part is the order: combining a parent and child transform in the wrong order can rotate around the wrong point while producing results that look mathematical enough to be believed. Check the engine's convention before arguing with the matrix. The matrix has already had a difficult day.

Vectors are the daily workhorses. Subtract one position from another to get a direction. Normalize it when only direction matters. Use a dot product to ask whether two directions agree, or a cross product to build a perpendicular normal. Movement is position plus velocity times elapsed time, which lets the same speed survive different frame rates. The surprise is that a zero-length direction is not a disappointing vector. It is a state that needs a decision before any normalization happens.

Quaternions handle rotation when Euler angles become awkward. Euler angles are readable, but two axes can align and remove a degree of freedom. A quaternion avoids that trap and supports smooth rotation interpolation. Use lerp for positions and scalar values. Use slerp for rotations. Treating a quaternion as four unrelated values is how a smooth turn becomes a small geometric protest.

Bounding volumes make collision checks affordable by asking a cheap question first. An AABB or sphere overlap says two objects might touch, not that the final shapes do. The usual sequence is broad approximation, then a more precise check when needed. The same habit applies across this subject: identify the space, representation, and approximation before trusting the number that comes out.

Read the Introduction when the names and relationships need a full map. Use Slides for the compact comparison of spaces, rotations, cameras, and collision tests. Keep the Cheatsheet beside implementation work for formulas and failure signals. The Practice Reference turns those formulas into worked calculations, and the exercise joins them into one steering behavior. That is enough to make the engine's math helpers feel less like ceremonial buttons and more like tools with consequences.

Where this skill leads

Relevant careers

See how this topic contributes to broader role-level skill maps.

Game Developercore

Sources