Discrete and Continuous Values

When developing games, we frequently need to work with both continuous values (like physics positions) and discrete ones (like screen pixels).

In this lesson, we'll explore the challenges of working with floating point numbers in different coordinate spaces and learn practical techniques to avoid common pitfalls related to precision and comparison.

We’ll be using the Vec2 struct we created earlier in the course. A complete version of it is available below:

1#pragma once
2#include <iostream>
3
4struct Vec2 {
5  float x;
6  float y;
7
8  float GetLength() const {
9    return std::sqrt(x * x + y * y);
10  }
11
12  float GetDistance(const Vec2& Other) const {
13    return (*this - Other).GetLength();
14  }
15
16  Vec2 Normalize() const {
17    return *this / GetLength();
18  }
19
20  Vec2 operator*(float Multiplier) const {
21    return Vec2{x * Multiplier, y * Multiplier};
22  }
23
24  Vec2 operator/(float Divisor) const {
25    if (Divisor == 0.0f) { return Vec2{0, 0}; }
26
27    return Vec2{x / Divisor, y / Divisor};
28  }
29
30  Vec2& operator*=(float Multiplier) {
31    x *= Multiplier;
32    y *= Multiplier;
33    return *this;
34  }
35
36  Vec2& operator/=(float Divisor) {
37    if (Divisor == 0.0f) { return *this; }
38
39    x /= Divisor;
40    y /= Divisor;
41    return *this;
42  }
43
44  Vec2 operator+(const Vec2& Other) const {
45    return Vec2{x + Other.x, y + Other.y};
46  }
47
48  Vec2 operator-(const Vec2& Other) const {
49    return *this + (-Other);
50  }
51
52  Vec2& operator+=(const Vec2& Other) {
53    x += Other.x;
54    y += Other.y;
55    return *this;
56  }
57
58  Vec2& operator-=(const Vec2& Other) {
59    return *this += (-Other);
60  }
61
62  Vec2 operator-() const {
63    return Vec2{-x, -y};
64  }
65};
66
67inline Vec2 operator*(float M, const Vec2& V) {
68  return V * M;
69}
70
71inline std::ostream& operator<<(
72  std::ostream& Stream, const Vec2& V) {
73  Stream << "{ x = " << V.x
74    << ", y = " << V.y << " }";
75  return Stream;
76}

Discrete and Continuous Spaces

When we write code that positions and moves objects through spaces using floating point numbers, we have to consider the fact that, unlike discrete integers, floating point numbers are continuous.

• Discrete numbers, such as those represented by an int, can only take one of a specific set of values. For example, there are only two possible integers between $2$ and $5$ - the integers $3$ and $4$
• Continuous numbers, such as those represented by a float, can potentially take any value. For example, there are conceptually endless floating point numbers between $2$ and $5$, with values such as $2.4$, $2.41$, and $2.40000001$.

These concepts extend to spaces too. For example:

• An SDL_Surface is a discrete space, as there are a limited number of possible positions within the space. Each possible position is represented by an x and y integer and corresponds to a pixel on the surface.
• World space is typically set up as continuous, where we use floating-point numbers to represent a conceptually endless range of possible positions in the space. This gives us, or the simulations we create, the ability to control objects’ positions and movements much more accurately.

One implication of working with continuous spaces is that we need to become accustomed to working with approximations. Even though we tend to think of floating point numbers as having simple values like $2.4$, we shouldn’t expect to be handling such well-rounded numbers in a continuous space. A value in such a space is just as likely to be $2.400000317$ as it is to be exactly $2.4$.

Floating Point Comparisons

The main scenario in which we need to be aware of the inherent approximations of continuous values and work around them is when we’re trying to do equality comparisons.

For example, our gameplay logic might need to determine whether two objects are in the same position, so it might seem reasonable to write a check like this:

1struct Object{
2  Vec2 Position;
3};
4
5bool IsInSamePosition(Object& A, Object& B) {
6  return A.Position.x == B.Position.x
7    && A.Position.y == B.Position.y; 
8}

However, when our objects are being simulated in a continuous space using floating point numbers, it’s very unlikely that their positions would be exactly equal. As such, an equality comparison using == will almost always return false, even if the object positions are so similar we would want to consider them as being equal for our simulation or gameplay needs.

For example, the numbers 2.39999958 and 2.40000031 are not entirely equal. However in most contexts, including computer graphics, we’d consider them close enough to be treated as equal. Therefore, we need to create alternatives to the == and != operators that check if objects are "close enough".

The common way of doing this is creating a function that accepts our two objects, and returns true if the difference between them is sufficiently small. This "sufficiently small" tolerance level is sometimes offered as a third argument with a default value, allowing users of the function to specify how small the difference between the values must be for them to be considered equal.

The following is an example of such a function that compares float objects, and an overload that uses similar concepts for comparing Vec2 objects. If it’s unclear why we’re using std::abs() here, we cover that in the next section:

1#include <cmath> // For std::abs
2
3// For Float Comparison
4bool NearlyEqual(float A, float B,
5                 float Tolerance = 0.00001) {
6  return std::abs(A - B) < Tolerance;
7}
8
9// For Vec2 Comparison
10bool NearlyEqual(const Vec2& A, const Vec2& B,
11                 float Tolerance = 0.00001) {
12  return std::abs(A.x - B.x) < Tolerance
13    && std::abs(A.y - B.y) < Tolerance;
14}

Our NearlyEqual() function would replace the == and != operators as follows:

1if (A == B) {/*...*/} 
2if (NearlyEqual(A, B)) {/*...*/} 
3
4if (A != B) {/*...*/} 
5if (!NearlyEqual(A, B)) {/*...*/}

A similar rationale applies to other comparisons, such as <= and <. For example, if A and B are approximately equal, we may not want to consider A to be meaningfully smaller than B even if A < B is technically true.

As such, we may also need to implement alternatives to these operators that make this distinction, should we ever need such logic. However, in practice, this is much less important than the == and != alternatives.

Avoiding Floating Point Numbers

Unlike with discrete numbers like integers, the underlying limitations of computer architecture makes exact floating point representations difficult, even when we’re not doing fine-grained simulations.

This limitation leads to quirks where approximations are used even in contexts where we wouldn’t expect them, such as when we’re directly using somewhat round numbers. For example, the result of 0.1 + 0.2 is not exactly equal to 0.3, which can result in unexpected behavior:

1#include <iostream>
2
3int main() {
4  if (0.1 + 0.2 == 0.3) {
5    std::cout << "Obviously equal";
6  } else {
7    std::cout << "Somehow not equal";
8  }
9}

1Somehow not equal

As such, it’s often a good idea to determine if our problem (or the entire program) has a reasonable way to avoid floating point numbers entirely.

For example, when dealing with financial values, it would seem intuitive to store a value like $3.57 as the floating point number 3.57. Instead, it is typically recommended that we store such values as cents rather than dollars. This means we would represent a value like $3.57 as the discrete integer 357, avoiding floating point numbers entirely.

There are rarely such simple alternatives that we can use when working on things like graphics and physics simulations. In those contexts, we just embrace floating point numbers, remaining mindful of their inexact nature and working around it when required:

1#include <iostream>
2
NearlyEqual Function (Unchanged)|Show
3bool NearlyEqual(float, float){/*...*/}
8
9int main() {
10  if (NearlyEqual(0.1 + 0.2, 0.3)) {
11    std::cout << "Obviously equal";
12  } else {
13    std::cout << "Somehow not equal";
14  }
15}

1Obviously equal

Vectors and Absolute Values

This previous code is an example where we use the concept of an absolute value, which we can revisit briefly here as it has some renewed meaning in the context of vectors.

As a reminder, we can consider taking the absolute value of a number to be removing that number’s negative component, if it has one.

For example, the absolute value of $-3$ is $3$. If a number is not negative, the absolute value is the same as the number itself, so the absolute value of $3$ is $3$.

To get the absolute value of an expression in C++, we can use std::abs() within the <cmath> standard library or, alternatively, SDL_abs() if we’re using SDL:

1#include <iostream>
2#include <cmath> // For std::abs
3#include <SDL.h> // For SDL_abs
4
5int main() {
6  float A{3};
7  float B{-3};
8
9  std::cout << "A: " << A;
10  std::cout << ", abs(A): " << std::abs(A);
11
12  std::cout << "\nB: " << B;
13  std::cout << ", abs(B): " << SDL_abs(B);
14}

1A: 3, abs(A): 3
2B: -3, abs(B): 3

In our NearlyEqual() function, we’re using the absolute value to make the argument order of $A$ and $B$ unimportant. $A - B$ is not necessarily the same as $B - A$, but the absolute values of $A - B$ and $B - A$ will be the same:

1#include <iostream>
2#include <cmath> // For std::abs
3
4int main() {
5  float A{1.001};
6  float B{0.999};
7
8  using std::abs;
9  std::cout << "A - B:    " << A - B;
10  std::cout << "\nB - A:    " << B - A;
11  std::cout << "\nabs(A-B): " << abs(A - B);
12  std::cout << "\nabs(B-A): " << abs(B - A);
13}

1A - B:    0.00200003
2B - A:    -0.00200003
3abs(A-B): 0.00200003
4abs(B-A): 0.00200003

Conceptually, we can imagine an expression like abs(A - B) calculating the distance between A and B, without caring about the direction. In mathematical notation, the absolute value of a number is represented by vertical bars, for example:

$$\lvert -3 \rvert = 3$$

This vertical bar notation is the same one we use when referencing the magnitude of a vector, as in $\lvert V \rvert$, because they’re fundamentally the same idea. The absolute value of some number, $\lvert x \rvert$, is how far away that number is from $0$, whilst the magnitude of some two-dimensional vector, $\lvert (x, y) \rvert$, is the straight-line distance from that vector to $(0, 0)$ - the origin.

We can even consider a number like $-3$ to be a one-dimensional vector in a one-dimensional space, which makes the similarity even more obvious. A one-dimensional space is simply a number line:

Continuous to Discrete Conversions

After we’ve run our simulation and calculated the position of all the objects in our continuous world space, we’ll often need to transform these vectors to equivalent positions in a discrete space. For example, the screen space representation using SDL_Surface is discrete - there is a fixed quantity of pixels on our surface, represented by integers.

We cover how to implement this full world space to screen space pipeline in the next chapter, but for now, we should note that converting a floating point number directly to an integer discards the floating point component. This is generally less accurate than we’d like - for example, it results in $3.8$ being converted to $3$, even though it’s closer to $4$:

1#include <iostream>
2
3int main() {
4  std::cout << "Converting 3.8 to int: "
5    << static_cast<int>(3.8);
6}

1Converting 3.8 to int: 3

To fix this, we can explicitly round our floating point numbers to the nearest integer. We can do this using std::round() from <cmath>, or SDL_round() if we’re using SDL:

1#include <iostream>
2
3#include <cmath> // For std::round
4#include <SDL.h> // For SDL_round
5
6int main() {
7  std::cout << "Rounding 3.8 to int: "
8    << std::round(3.8);
9  std::cout << "\nRounding 3.8 to int: "
10    << SDL_round(3.8);
11}

1Rounding 3.8 to int: 4
2Rounding 3.8 to int: 4

In the following example, we incorporate this rounding into our transformation function from world space to screen space. This ensures our Vec2 components are integer values:

1#include <cmath> // For std::round
2
3Vec2 ToScreenSpace(const Vec2& Pos) {
4  return {
5    std::round(Pos.x * 0.5f),
6    std::round((Pos.y * -0.5f) + 300)
7  };
8}

Even though these values are now integers, they are being stored in float containers - the x and y variables of our Vec2 type. This is not necessarily a problem as almost every implementation of the float type uses the IEEE 754 standard, which can accurately represent integer values up to $2^24$ (approximately 16.7 million) without any loss of precision.

Preserving the floating point type in screen space is also useful if we need to perform further transformations within that space, and having access to floating-point accuracy would be helpful in that work.

In such cases, we’d also want to hold off on rounding our values to integers until we complete those transformations. We don’t want to round our values multiple times, as each rounding has a performance cost and may also represent a loss of data/accuracy.

Summary

Working with continuous values in games requires specific techniques to ensure precision and correctness. Throughout this lesson, we've seen how to properly compare floating point values, understand their limitations, and transform them accurately to screen space coordinates. Here are the key points:

• Floating-point numbers require special considerations when comparing values or converting to integer pixels.
• We should be extremely cautious with using the == and != operators with floating point numbers. It’s usually the case that we should consider floating point values to be equivalent if their difference is very small, but not necessarily $0$.
• Converting floating point numbers to integers directly often results in loss of accuracy, as that action just discards the floating point component, effectively always rounding down. We typically want to round them to the nearest integer instead.

Free and Unlimited Access

Professional C++

Unlock the true power of C++ by mastering complex features, optimizing performance, and learning expert workflows used in professional development

View Course