Angles and Distance

Distance Between Any Two Points

Often, we don’t care how far an object is from the origin. Rather, we want to know how far away our object is from some other object.

The technique using the Pythagorean theorem applies to this situation, too. We can create a right-angled triangle from any two points:

In this example, the side lengths of our right angle triangle have a length of $5$ and $3$, so we can calculate how far apart points $A$ and $B$ are:

Calculating Side Lengths

It may be obvious why we choose the values $5$ and $3$ to insert into the formula - we can see those values in our diagram. However, we generally won't have a visual representation to work from.

Therefore, it is worth understanding how we would come to these values in a level of detail that allows us to create a general algorithm, like a C++ function.

In the general case, $A$ and $B$ will be points - like Vec2 instances - that are passed to our function. We won't know the horizontal and vertical distance between them - we need to work it out. So how did we get the values that were, in this case, $5$ and $3$?

• We took the $x$ coordinate of point $B$ and subtracted the $x$ coordinate of point $A$. That gave us $7 - 2 = 5$
• We took the $y$ coordinate of point $B$ and subtracted the $y$ coordinate of point $A$. That gave us $4 - 1 = 3$

In other words, we did $A_\text{x} - B_\text{x}$ and $B_\text{y} - A_\text{y}$ to get the two sides of our right-angled triangle.

Which Point is $A$ and Which is $B$?

When calculating the distance between two points, you might wonder if the order matters. Let's investigate what happens when we swap the points in our calculation:

• If we use $A$ first, we calculate $A_\text{x} - B_\text{x}$ and $A_\text{y} - B_\text{y}$
• If we use $B$ first, we calculate $B_\text{x} - A_\text{x}$ and $B_\text{y} - A_\text{y}$

These expressions will have opposite signs. For example, if $A_\text{x} - B_\text{x} = 5$, then $B_\text{x} - A_\text{x} = -5$

However, in the distance formula, we square these differences: $(A_\text{x} - B_\text{x})^2$ and $(A_\text{y} - B_\text{y})^2$.

Since the square of a number is always positive (whether the original number was positive or negative), we get the same result either way:

• $5^2 = 25$
• $(-5)^2 = 25$

Therefore, the distance calculated will be identical regardless of which point you designate as $A$ and which as $B$. This makes sense intuitively - the distance from London to Paris is the same as the distance from Paris to London.

Distance Formula

We can use the approach we covered here to expand the Pythagorean theorem to a new formula. This new formula allows us to calculate the distance between any two points. Let’s call our points $A$ and $B$ and, for now, we'll assume we're working in a two-dimensional space:

This formula is sometimes referred to as the distance formula. In C++, we could implement it like this:

1#include <iostream>
2#include <cmath>
3
4struct Vec2 {
5  float x;
6  float y;
7
8  float GetDistance(const Vec2& Other) const {
9    return std::sqrt(
10      std::pow(x - Other.x, 2) +
11      std::pow(y - Other.y, 2)
12    );
13  }
14};
15
16int main() {
17  Vec2 A{2, 1};
18  Vec2 B{7, 4};
19  std::cout << "Distance between points: "
20    << A.GetDistance(B);
21}

1Distance between points: 5.83095

Going 3D

The examples above used two dimensions in their examples and illustrations, but the techniques apply to three-dimensional spaces too.

In cartesian coordinate systems, the 3rd dimension is generally identified by the letter $z$, to give coordinates $(x, y, z)$.

1// Vec3.h
2#pragma once
3
4struct Vec3 {
5  float x;
6  float y;
7  float z;
8};

The origin of a three-dimensional cartesian space is $(0, 0, 0)$

The Pythagorean theorem expands to three dimensions. To calculate how far a three-dimensional point $(x, y, z)$ is from the origin, we add the $z$ component as follows:

Similarly, the distance formula also expands to three dimensions. To calculate the distance between point $A$ with coordinates $(A_\text{x}, A_\text{y}, A_\text{z})$ and point $B$ with coordinates $(B_\text{x}, B_\text{y}, B_\text{z})$, we calculate:

Summary

We've covered essential geometric concepts that form the foundation of many game mechanics. From understanding angles and right-angled triangles to implementing the Pythagorean theorem in C++, you now have the tools to calculate distances between game objects. Key takeaways:

• Angles measure the space between intersecting lines, with 90° forming right angles
• Right-angled triangles have special properties that make them useful for distance calculations
• The Pythagorean theorem $h = \sqrt{a^2 + b^2}$ helps calculate the hypotenuse of right-angled triangles
• Vector magnitude represents how far a point is from the origin
• The distance formula allows us to calculate distances between any two points in space
• We can extend these formulas to work in 3D by adding the z-component