2.2 Trigonometry & Geometry

Every object in a game has a position, and most of them also have a direction: which way a character faces, which way a bullet flies, which way a camera looks. Turning "which way" into numbers is trigonometry (the math of angles and circles). This chapter also covers the basic shapes games use for collision: circles, boxes, rays, and the tests that ask "did these two things touch?" You already know C++ basics and how to reason about data — this chapter is smaller code, more math, but the same pattern: code, real output, plain explanation.

Type the examples in and run them yourself. Trig bugs are usually invisible until you see the wrong number on screen, so getting comfortable with the real output now will save you real debugging time later.

1. Radians vs degrees: the two ways to measure an angle

An angle can be measured in degrees (a full circle is 360) or in radians (a full circle is 2*pi, about 6.28318). Degrees are what humans use ("turn 90 degrees"). Radians are what almost every math library uses internally, including C++'s <cmath> functions like sin, cos, and atan2. If you pass degrees where radians are expected, you get a wrong answer with no error or warning — the function still returns a number, just the wrong one.

The conversion is a straight ratio: 360 degrees equals 2*pi radians, so 180 degrees equals pi radians. That gives two formulas:

radians = degrees * (PI / 180.0)
degrees = radians * (180.0 / PI)

#include <iostream>

const double PI = 3.14159265358979323846;   // C++ has no standard PI constant,
                                             // so define your own once, here
double toRadians(double degrees) { return degrees * PI / 180.0; }
double toDegrees(double radians) { return radians * 180.0 / PI; }

int main() {
    double degs[] = {0, 45, 90, 180, 270, 360};
    for (double d : degs)
        std::cout << d << " degrees = " << toRadians(d) << " radians\n";
}

Output:

0 degrees = 0 radians
45 degrees = 0.785398 radians
90 degrees = 1.5708 radians
180 degrees = 3.14159 radians
270 degrees = 4.71239 radians
360 degrees = 6.28319 radians

Check the pattern: 90 degrees became about 1.57, which is pi/2 (3.14159 / 2). 180 degrees became 3.14159, which is exactly pi. That is the whole relationship — degrees and radians are just two different rulers for measuring the same turn.

2. sin, cos, tan, and the unit circle

You may have learned sine, cosine, and tangent from a right triangle: for an angle theta (theta) inside the triangle, sin(theta) = opposite / hypotenuse, cos(theta) = adjacent / hypotenuse, and tan(theta) = opposite / adjacent (the mnemonic SOH-CAH-TOA). That definition is correct but clunky for games, because game code rarely has a triangle lying around — it has an angle and wants a direction.

The unit circle is a circle of radius 1 centered at the origin (0,0). Picture standing at the center and turning by an angle theta, measured counter-clockwise from the positive x-axis. Walk out to the edge of the circle. The point you land on is always (cos(theta), sin(theta)). That is the entire trick: cos gives the x-coordinate, sin gives the y-coordinate, for a point exactly 1 unit from the center, at angle theta.

Why does this match the triangle definition? Drop a straight line from point P down to the x-axis. That makes a right triangle where the hypotenuse is the radius (length 1), the adjacent side has length cos(theta), and the opposite side has length sin(theta). Because the hypotenuse is exactly 1, the fractions "opposite/hypotenuse" and "adjacent/hypotenuse" simplify to just the opposite and adjacent lengths themselves. Same math, simpler picture.

#include <iostream>
#include <cmath>
#include <iomanip>

const double PI = 3.14159265358979323846;

int main() {
    std::cout << std::fixed << std::setprecision(3);
    double anglesDeg[] = {0, 30, 45, 60};
    for (double d : anglesDeg) {
        double rad = d * PI / 180.0;
        std::cout << "deg=" << d
                  << " cos=" << std::cos(rad)
                  << " sin=" << std::sin(rad)
                  << " tan=" << std::tan(rad) << "\n";
    }
}

Output:

deg=0 cos=1.000 sin=0.000 tan=0.000
deg=30 cos=0.866 sin=0.500 tan=0.577
deg=45 cos=0.707 sin=0.707 tan=1.000
deg=60 cos=0.500 sin=0.866 tan=1.732

Read the 45-degree row: cos=0.707 and sin=0.707 — equal, because at 45 degrees you have walked exactly halfway between "all x" and "all y". And tan is just sin/cos at every row (check 60 degrees: 0.866 / 0.500 = 1.732) — tangent is the ratio of the other two, not a separate idea.

#include <iostream>
#include <cmath>

int main() {
    double rad = 1.5707963267948966;   // 90 degrees in radians
    double c = std::cos(rad);
    double t = std::tan(rad);
    std::cout << "cos(90) = " << c << "\n";
    std::cout << "tan(90) = " << t << "\n";
    std::cout << (c == 0.0 ? "exactly zero" : "NOT exactly zero") << "\n";
}

Output:

cos(90) = 6.12323e-17
tan(90) = 1.63312e+16
NOT exactly zero

cos(90 degrees) should mathematically be 0, but it prints 6.12323e-17 — a number so tiny it is meaningless, yet not the same bit pattern as 0.0. Because tan = sin/cos, dividing by that almost-zero number blows up into a huge, meaningless value instead of the "undefined" you would expect. The lesson: never compare a trig result to a value with ==. Compare against a small tolerance instead, like std::fabs(c) < 0.0001.

3. Moving in a circle with sin and cos

Once you can turn an angle into a point on the unit circle, moving something in a circle is one line: scale the unit-circle point by the circle's radius, and shift it by the circle's center.

#include <iostream>
#include <cmath>
#include <iomanip>

const double PI = 3.14159265358979323846;

int main() {
    std::cout << std::fixed << std::setprecision(3);
    double radius = 5.0;
    int steps = 5;
    for (int i = 0; i < steps; i++) {
        double angle = (2.0 * PI / steps) * i;   // spread evenly around the circle
        double x = radius * std::cos(angle);
        double y = radius * std::sin(angle);
        std::cout << "step " << i << ": angle=" << angle
                  << " pos=(" << x << ", " << y << ")\n";
    }
}

Output:

step 0: angle=0.000 pos=(5.000, 0.000)
step 1: angle=1.257 pos=(1.545, 4.755)
step 2: angle=2.513 pos=(-4.045, 2.939)
step 3: angle=3.770 pos=(-4.045, -2.939)
step 4: angle=5.027 pos=(1.545, -4.755)

Five steps, evenly spaced around a circle of radius 5, all centered on the origin. Notice the points form a five-pointed pattern around (0,0), each one exactly 5 units from the center (you can check: 1.545^2 + 4.755^2 works out to about 25, which is radius^2). In a real game, "angle" would grow a little bit every frame (angle += turnSpeed * deltaTime) instead of jumping in five fixed steps — that is how you animate an orbiting satellite, a sweeping radar line, or the hands of a clock.

4. Rotating a 2D vector by an angle

Section 3 rotated a point around the origin using an ever-changing angle. Now the more general tool: given any 2D vector (x, y) and an angle, produce the same vector turned by that angle. This is called a rotation, and the formula is:

You do not need to derive this to use it — treat it as a recipe, the same way you treat sqrt as a recipe. It takes a vector and spins it around (0,0) by angle, counter-clockwise for a positive angle.

#include <iostream>
#include <cmath>
#include <iomanip>

const double PI = 3.14159265358979323846;

struct Vec2 { double x, y; };

Vec2 rotate(Vec2 v, double angleRad) {
    double c = std::cos(angleRad);
    double s = std::sin(angleRad);
    return { v.x * c - v.y * s,    // new x
             v.x * s + v.y * c };  // new y
}

int main() {
    std::cout << std::fixed << std::setprecision(3);
    Vec2 v = {2.0, 0.0};
    double anglesDeg[] = {0, 90, 180, 270};
    for (double deg : anglesDeg) {
        Vec2 r = rotate(v, deg * PI / 180.0);
        std::cout << deg << " deg: (" << r.x << ", " << r.y << ")\n";
    }
}

Output:

0 deg: (2.000, 0.000)
90 deg: (0.000, 2.000)
180 deg: (-2.000, 0.000)
270 deg: (0.000, -2.000)

Start with the vector pointing right, (2, 0). Rotate it 90 degrees and it points straight up, (0, 2). Another 90 and it points left, (-2, 0). Another 90 and it points down, (0, -2). It walked around a full circle in four quarter-turns, always keeping its length (2 units).

5. Aiming at a target: atan2 and the direction vector

Sections 3 and 4 went from an angle to a position or a rotated vector. Aiming is the reverse problem: you have two positions — the shooter and the target — and you want the angle between them. The tool for that is atan2(dy, dx), which takes a y difference and an x difference and returns the angle of the vector (dx, dy), measured the same way as the unit circle in section 2.

#include <iostream>
#include <cmath>
#include <iomanip>

const double PI = 3.14159265358979323846;
double toDegrees(double rad) { return rad * 180.0 / PI; }

int main() {
    std::cout << std::fixed << std::setprecision(2);
    struct { double dx, dy; } targets[] = {
        {5, 0}, {0, 5}, {-5, 0}, {0, -5}, {3, 3}
    };
    for (auto t : targets) {
        double angle = std::atan2(t.dy, t.dx);
        std::cout << "dx=" << t.dx << " dy=" << t.dy
                  << " -> angle=" << toDegrees(angle) << " deg\n";
    }
}

Output:

dx=5.00 dy=0.00 -> angle=0.00 deg
dx=0.00 dy=5.00 -> angle=90.00 deg
dx=-5.00 dy=0.00 -> angle=180.00 deg
dx=0.00 dy=-5.00 -> angle=-90.00 deg
dx=3.00 dy=3.00 -> angle=45.00 deg

Every result matches the unit circle picture: a target straight right is 0 degrees, straight up is 90, straight left is 180, straight down is -90 (negative, since it turned the other way), and diagonally up-right is 45.

Once you have the angle, section 2's trick turns it back into a direction: (cos(angle), sin(angle)) is a unit vector (length exactly 1) pointing straight at the target. Scale that by a speed and you get a velocity that homes in on the target — this is exactly how a simple homing bullet or a "look at player" rotation works.

#include <iostream>
#include <cmath>
#include <iomanip>

int main() {
    std::cout << std::fixed << std::setprecision(2);

    double px = 0, py = 0;      // bullet start position
    double tx = 8, ty = 6;      // target position (does not move)
    double speed = 5.0;         // units per step

    double dx = tx - px;
    double dy = ty - py;
    double angle = std::atan2(dy, dx);     // angle from bullet to target

    double vx = std::cos(angle) * speed;   // velocity x
    double vy = std::sin(angle) * speed;   // velocity y

    std::cout << "aim angle = " << angle << " rad\n";
    for (int step = 1; step <= 3; step++) {
        px += vx;
        py += vy;
        std::cout << "step " << step << ": pos=(" << px << ", " << py << ")\n";
    }
}

Output:

aim angle = 0.64 rad
step 1: pos=(4.00, 3.00)
step 2: pos=(8.00, 6.00)
step 3: pos=(12.00, 9.00)

The target is at (8, 6), which happens to be exactly 10 units away (an 6-8-10 right triangle, like the familiar 3-4-5 one but doubled). At speed 5, the bullet covers that distance in exactly 2 steps, landing precisely on (8, 6) — then keeps going past it on step 3, since nothing tells it to stop. A real homing bullet would recompute angle every frame toward the target's current position, and check the remaining distance so it can stop or explode on arrival.

6. Lines, rays, and planes

Before the collision tests, you need the shapes those tests work on. Three "infinite" shapes show up constantly:

• A line extends forever in both directions. It can be described by any point on it plus a direction.
• A ray starts at one point (the origin) and extends forever in a single direction — like a laser beam or a bullet's path. This is the shape used for aiming checks, mouse picking, and line-of-sight.
• A plane is a flat, infinite sheet (in 3D). In 2D the equivalent is just a line, but described a different way: by a point on it and a normal (a vector pointing straight out, perpendicular to the surface).

A ray is written as a formula: pick any number t >= 0, and the point at "distance" t along the ray is origin + t * direction. Larger t means further along the ray. This t shows up again in every intersection test later in this chapter — it is always "how far along the ray did we hit something."

#include <iostream>

struct Vec2 { double x, y; };

Vec2 pointOnRay(Vec2 origin, Vec2 dir, double t) {
    return { origin.x + t * dir.x, origin.y + t * dir.y };
}

int main() {
    Vec2 origin = {0, 0};
    Vec2 dir    = {1, 0.5};    // the direction the ray travels

    for (double t = 0; t <= 3; t += 1.0) {
        Vec2 p = pointOnRay(origin, dir, t);
        std::cout << "t=" << t << " -> point=(" << p.x << ", " << p.y << ")\n";
    }
}

Output:

t=0 -> point=(0, 0)
t=1 -> point=(1, 0.5)
t=2 -> point=(2, 1)
t=3 -> point=(3, 1.5)

Now the dot product — a small tool you will use repeatedly from here on. For two vectors a and b, dot(a, b) = a.x*b.x + a.y*b.y. It is one number, not a vector, and its sign tells you how the two vectors point relative to each other.

#include <iostream>

struct Vec2 { double x, y; };

double dot(Vec2 a, Vec2 b) { return a.x * b.x + a.y * b.y; }

int main() {
    Vec2 right     = {1, 0};
    Vec2 up        = {0, 1};
    Vec2 alsoRight = {5, 0};
    Vec2 leftish   = {-1, 0.2};

    std::cout << "right . up = "        << dot(right, up)        << "\n";
    std::cout << "right . alsoRight = " << dot(right, alsoRight) << "\n";
    std::cout << "right . leftish = "   << dot(right, leftish)   << "\n";
}

Output:

right . up = 0
right . alsoRight = 5
right . leftish = -1

right and up are perpendicular (90 degrees apart) and their dot product is exactly 0 — that is a general rule: dot product is 0 when two vectors are perpendicular. right and alsoRight point the same way, and the dot product came out positive. right and leftish point mostly opposite ways, and it came out negative. Positive means "generally the same direction", negative means "generally opposite", zero means "perpendicular".

That sign trick is exactly how a plane's signed distance works: for a plane with normal n passing through point Q, a point P's signed distance from the plane is dot(n, P - Q). Zero means P is on the plane, positive means P is on the side the normal points toward, negative means the other side.

#include <iostream>

struct Vec2 { double x, y; };
double dot(Vec2 a, Vec2 b) { return a.x * b.x + a.y * b.y; }

int main() {
    Vec2 pointOnPlane = {0, 0};   // the ground, at y=0
    Vec2 normal       = {0, 1};   // "up" is the positive side

    Vec2 above = {3, 5};
    Vec2 below = {3, -2};

    Vec2 toAbove = { above.x - pointOnPlane.x, above.y - pointOnPlane.y };
    Vec2 toBelow = { below.x - pointOnPlane.x, below.y - pointOnPlane.y };

    std::cout << "above: signed dist = " << dot(normal, toAbove) << "\n";
    std::cout << "below: signed dist = " << dot(normal, toBelow) << "\n";
}

Output:

above: signed dist = 5
below: signed dist = -2

The point (3, 5) is 5 units above the ground plane, and the formula reports +5. The point (3, -2) is 2 units below, and it reports -2. In 3D this exact formula (with a 3D normal and a 3D point) is how engines test which side of the ground, a wall, or a camera frustum face something is on.

7. Circles, spheres, and axis-aligned boxes (AABB)

Checking whether two detailed character meshes overlap, triangle by triangle, is expensive. Games almost never do that directly. Instead they wrap each object in a simple bounding shape and test that instead — cheap, approximate, and good enough for most gameplay. The two simplest bounding shapes are the circle (sphere in 3D) and the box.

A circle needs just a center and a radius. In 3D the same idea is called a sphere. An AABB (axis-aligned bounding box) is a rectangle (or, in 3D, a box) whose edges are always parallel to the x and y axes — it never rotates. That restriction is what makes it cheap: you only ever need to store two corners, the minimum corner and the maximum corner.

#include <iostream>

struct Vec2 { double x, y; };

struct Circle {
    Vec2 center;
    double radius;
};

struct AABB {              // Axis-Aligned Bounding Box
    Vec2 min;                // corner with the smallest x and y
    Vec2 max;                // corner with the largest x and y
};

int main() {
    Circle c = { {10.0, 10.0}, 3.0 };
    AABB box = { {0.0, 0.0}, {4.0, 2.0} };

    std::cout << "circle: center=(" << c.center.x << "," << c.center.y
              << ") radius=" << c.radius << "\n";

    double width  = box.max.x - box.min.x;
    double height = box.max.y - box.min.y;
    std::cout << "box: width=" << width << " height=" << height << "\n";
}

Output:

circle: center=(10,10) radius=3
box: width=4 height=2

Nothing fancy: the circle stores three numbers, the box stores four (two corners), and both let you recover any other useful measurement (width, height, diameter) with simple subtraction.

8. Point-in-circle and point-in-rectangle tests

The simplest collision question is "is this single point inside this shape?" — used for mouse clicks, spawn checks, and trigger zones. For a circle, a point is inside when its distance to the center is less than or equal to the radius.

#include <iostream>

struct Vec2 { double x, y; };

bool pointInCircle(Vec2 p, Vec2 center, double radius) {
    double dx = p.x - center.x;
    double dy = p.y - center.y;
    double distSq = dx*dx + dy*dy;         // squared distance -- no sqrt needed
    return distSq <= radius * radius;
}

int main() {
    Vec2 center = {0, 0};
    double radius = 5.0;

    Vec2 inside  = {3, 4};   // distance = 5 exactly (a 3-4-5 triangle)
    Vec2 outside = {5, 5};   // distance = sqrt(50) ~= 7.07

    std::cout << "inside point in circle? "  << pointInCircle(inside, center, radius)  << "\n";
    std::cout << "outside point in circle? " << pointInCircle(outside, center, radius) << "\n";
}

Output:

inside point in circle? 1
outside point in circle? 0

(3, 4) is exactly 5 units from the origin (3-4-5 right triangle), which is exactly the radius — the boundary counts as "inside" here because the test uses <=. (5, 5) is about 7.07 units away, further than the radius, so it fails. std::cout prints a bool as 1 for true and 0 for false.

A point-in-rectangle (AABB) test is even simpler: check that the point's x is between the box's min and max x, and separately that its y is between the box's min and max y.

#include <iostream>

struct Vec2 { double x, y; };
struct AABB { Vec2 min, max; };

bool pointInAABB(Vec2 p, AABB box) {
    return p.x >= box.min.x && p.x <= box.max.x
        && p.y >= box.min.y && p.y <= box.max.y;
}

int main() {
    AABB box = { {0, 0}, {10, 5} };

    Vec2 inside  = {4, 3};
    Vec2 outside = {12, 3};

    std::cout << "inside point in box? "  << pointInAABB(inside, box)  << "\n";
    std::cout << "outside point in box? " << pointInAABB(outside, box) << "\n";
}

Output:

inside point in box? 1
outside point in box? 0

Four comparisons, all "and"-ed together with &&. If any one of them fails, the point is outside. This is the cheapest intersection test in the whole chapter, and it is also the core building block AABB-vs-AABB collision reuses in the next section's cousin (box overlap tests just do this same min/max comparison on both boxes instead of a box and a point).

9. Distance from a point to a line

Sometimes you do not need "inside or outside", just "how far is this point from that line" — useful for things like keeping an object a minimum distance from a wall, or checking how close a shot passed to a target. This needs one more small tool: the 2D cross product. Unlike the 3D cross product (which returns a vector), the 2D version returns a single number: cross(a, b) = a.x*b.y - a.y*b.x. Its size relates to the area of the parallelogram the two vectors would form, and its sign tells you which side b is on relative to a.

#include <iostream>
#include <cmath>

struct Vec2 { double x, y; };

double distancePointToLine(Vec2 p, Vec2 a, Vec2 b) {
    Vec2 d  = { b.x - a.x, b.y - a.y };      // line direction (A to B)
    Vec2 ap = { p.x - a.x, p.y - a.y };      // vector from A to P
    double cross = d.x * ap.y - d.y * ap.x;  // 2D cross product (a single number)
    double lenD = std::sqrt(d.x*d.x + d.y*d.y);
    return std::fabs(cross) / lenD;
}

int main() {
    Vec2 a = {0, 0};
    Vec2 b = {10, 0};       // a horizontal line along the x-axis
    Vec2 p = {4, 3};

    std::cout << "distance = " << distancePointToLine(p, a, b) << "\n";
}

Output:

distance = 3

You can sanity-check this one by eye: the line runs along y = 0, and the point is at y = 3, so the perpendicular distance is obviously 3. The formula agrees: cross = 10*3 - 0*4 = 30, the line's length lenD = 10, and 30 / 10 = 3. The cross product measures the area of the parallelogram formed by the line's direction and the vector to the point; dividing by the line's length converts that area into a plain perpendicular distance.

10. Ray vs sphere (circle) intersection

This test answers "does this ray hit this circle, and if so, how far along the ray?" — the exact question a hitscan weapon, a mouse-picking ray, or a line-of-sight check needs answered. The geometric idea: find the point on the ray line closest to the circle's center, and see if that closest point is within the radius.

#include <iostream>
#include <cmath>

struct Vec2 { double x, y; };

double dot(Vec2 a, Vec2 b) { return a.x*b.x + a.y*b.y; }

bool raySphere(Vec2 origin, Vec2 dir, Vec2 center, double radius, double& tHit) {
    Vec2 L = { center.x - origin.x, center.y - origin.y };
    double tca = dot(L, dir);              // closest-approach distance along the ray
    double d2 = dot(L, L) - tca * tca;     // squared distance from center to the ray line
    double r2 = radius * radius;
    if (d2 > r2) return false;             // ray line misses the circle entirely

    double thc = std::sqrt(r2 - d2);       // half-chord length
    double t0 = tca - thc;                 // near hit
    double t1 = tca + thc;                 // far hit

    if (t0 >= 0) { tHit = t0; return true; }
    if (t1 >= 0) { tHit = t1; return true; }
    return false;                          // circle is entirely behind the ray's origin
}

int main() {
    Vec2 origin = {0, 0};
    Vec2 center = {10, 0};
    double radius = 2.0;

    Vec2 dir1 = {1, 0};    // points straight at the circle, unit length
    Vec2 dir2 = {0, 1};    // points straight up, away from the circle

    double t;
    if (raySphere(origin, dir1, center, radius, t))
        std::cout << "dir1: hit at t=" << t << "\n";
    else
        std::cout << "dir1: no hit\n";

    if (raySphere(origin, dir2, center, radius, t))
        std::cout << "dir2: hit at t=" << t << "\n";
    else
        std::cout << "dir2: no hit\n";
}

Output:

dir1: hit at t=8
dir2: no hit

The circle is centered at (10, 0) with radius 2, so it spans from x=8 to x=12 along the x-axis. The first ray fires straight along +x from the origin and, as expected, first touches the circle at x=8, which is t=8 steps along a unit-length direction. The second ray fires straight up — it never gets anywhere near x=10, so it misses no matter how far it travels, and the function correctly reports no hit.

11. Ray vs AABB: the slab test

The last test: does a ray hit an axis-aligned box? The classic method is called the slab test. Picture the box's x-range as a "slab" — an infinite strip between minX and maxX. Compute the range of t values where the ray is inside that strip. Do the same for the y-range. The ray actually hits the box only where both ranges overlap.

#include <iostream>
#include <algorithm>
#include <limits>

struct Vec2 { double x, y; };
struct AABB { Vec2 min, max; };

bool raySlabAABB(Vec2 origin, Vec2 dir, AABB box, double& tHit) {
    double tMin = -std::numeric_limits<double>::infinity();
    double tMax =  std::numeric_limits<double>::infinity();

    // X axis slab
    if (dir.x != 0.0) {
        double t1 = (box.min.x - origin.x) / dir.x;
        double t2 = (box.max.x - origin.x) / dir.x;
        if (t1 > t2) std::swap(t1, t2);
        tMin = std::max(tMin, t1);
        tMax = std::min(tMax, t2);
    } else if (origin.x < box.min.x || origin.x > box.max.x) {
        return false;   // parallel to the x-slab and outside it -- can never hit
    }

    // Y axis slab
    if (dir.y != 0.0) {
        double t1 = (box.min.y - origin.y) / dir.y;
        double t2 = (box.max.y - origin.y) / dir.y;
        if (t1 > t2) std::swap(t1, t2);
        tMin = std::max(tMin, t1);
        tMax = std::min(tMax, t2);
    } else if (origin.y < box.min.y || origin.y > box.max.y) {
        return false;
    }

    if (tMin > tMax || tMax < 0) return false;  // slabs don't overlap, or box is behind us
    tHit = tMin;
    return true;
}

int main() {
    AABB box = { {4, 1}, {8, 5} };

    Vec2 origin1 = {0, 3};
    Vec2 dir1    = {1, 0};    // straight along +x, at y=3 (inside the box's y-range)

    Vec2 origin2 = {0, 3};
    Vec2 dir2    = {0, 1};    // straight up -- x never reaches the box

    double t;
    if (raySlabAABB(origin1, dir1, box, t))
        std::cout << "ray1: hit at t=" << t << "\n";
    else
        std::cout << "ray1: no hit\n";

    if (raySlabAABB(origin2, dir2, box, t))
        std::cout << "ray2: hit at t=" << t << "\n";
    else
        std::cout << "ray2: no hit\n";
}

Output:

ray1: hit at t=4
ray2: no hit

Ray 1 starts at (0, 3) and moves along +x. Its y never changes, and 3 is already inside the box's y-range [1, 5], so the y-slab places no extra restriction. Its x-slab check finds it enters the box's x-range [4, 8] at t=4 — that becomes the answer. Ray 2 moves straight up from the same start; its x stays 0 forever, which is outside the box's x-range [4, 8] no matter how far it travels, so the very first check (dir.x == 0 and origin.x outside the slab) rejects it immediately.

12. Glossary

• Radian — a unit for measuring angles where a full circle is 2*pi; most math libraries expect radians, not degrees.
• Degree — the everyday unit for angles, where a full circle is 360.
• Unit circle — a circle of radius 1 centered at the origin; the point at angle theta on it is (cos(theta), sin(theta)).
• sin / cos / tan — trig functions giving the y-coordinate, x-coordinate, and their ratio for a point on the unit circle at a given angle.
• atan2(dy, dx) — returns the angle of the vector (dx, dy), correctly handling all four quadrants, unlike plain atan.
• Unit vector — a vector with length exactly 1; used to represent a pure direction.
• Rotation formula — new_x = x*cos(a) - y*sin(a), new_y = x*sin(a) + y*cos(a); spins a vector by angle a.
• Dot product — a.x*b.x + a.y*b.y; positive if vectors point similarly, negative if oppositely, zero if perpendicular.
• 2D cross product — a.x*b.y - a.y*b.x; a single number whose size relates to area and whose sign tells you which side.
• Ray — a half-infinite line: an origin point plus a direction, described by origin + t*direction for t >= 0.
• Plane — a flat, infinite surface described by a point on it and a normal vector.
• Normal vector — a vector perpendicular to a surface, usually kept at length 1.
• Signed distance — how far a point is from a plane/line, with a sign showing which side it is on.
• AABB — axis-aligned bounding box; a rectangle/box that never rotates, stored as a min corner and a max corner.
• Bounding shape — a simple shape (circle, box) wrapped around a more complex object for cheap collision checks.
• Broad phase / narrow phase — first ruling out obviously non-colliding pairs with cheap bounding-shape checks, then running exact checks only on what is left.
• Slab test — the standard ray-vs-AABB method: intersect the per-axis ranges of t where the ray is inside each axis's slab.
• t (ray parameter) — how far along a ray a point is, assuming the ray's direction is a unit vector.

13. Exercises

new_x = 1 * (-0.707107) - 0 * 0.707107 = -0.707
new_y = 1 * 0.707107 + 0 * (-0.707107) = 0.707

That covers the math a lot of gameplay code quietly leans on. Angles convert between degrees and radians with one formula; the unit circle turns any angle into a direction via sin/cos; atan2 turns any two positions into an aiming angle; and a handful of cheap shapes — circles, AABBs, rays — cover most of the collision questions a game asks every single frame. None of this needs to be memorized word for word; what matters is recognizing the shape of the problem ("I have two positions and need an angle" -> atan2; "I have a ray and a box" -> slab test) and knowing where to reach.