#### Overview of this book

Physics is really important for game programmers who want to add realism and functionality to their games. Collision detection in particular is a problem that affects all game developers, regardless of the platform, engine, or toolkit they use. This book will teach you the concepts and formulas behind collision detection. You will also be taught how to build a simple physics engine, where Rigid Body physics is the main focus, and learn about intersection algorithms for primitive shapes. You’ll begin by building a strong foundation in mathematics that will be used throughout the book. We’ll guide you through implementing 2D and 3D primitives and show you how to perform effective collision tests for them. We then pivot to one of the harder areas of game development—collision detection and resolution. Further on, you will learn what a Physics engine is, how to set up a game window, and how to implement rendering. We’ll explore advanced physics topics such as constraint solving. You’ll also find out how to implement a rudimentary physics engine, which you can use to build an Angry Birds type of game or a more advanced game. By the end of the book, you will have implemented all primitive and some advanced collision tests, and you will be able to read on geometry and linear Algebra formulas to take forward to your own games!
Game Physics Cookbook
Credits
Acknowledgements
Acknowledgements
www.PacktPub.com
Customer Feedback
Preface
Free Chapter
Vectors
Matrices
Matrix Transformations
2D Primitive Shapes
2D Collisions
2D Optimizations
3D Primitive Shapes
3D Point Tests
3D Shape Intersections
3D Line Intersections
Triangles and Meshes
Models and Scenes
Camera and Frustum
Constraint Solving
Manifolds and Impulses
Springs and Joints
Index

## Component-wise operations

Given two vectors, there are several component-wise operations we can perform. These operations will operate on each component of the vector and yield a new vector.

You can add two vectors component wise. Given two n-dimensional vectors and , addition is defined as follows:

You can also subtract two vectors component wise. Given two n-dimensional vectors and , subtraction is defined as follows:

Multiplying two vectors can also be done component wise. There are other ways to multiply two vectors; the dot product or cross product. Both of these alternate methods will be covered later in this chapter. Given two n-dimensional vectors and , multiplication is defined as follows:

In addition to multiplying two vectors, you can also multiply a vector by a scalar. In this context, a scalar is any real number. Given vector and scalar S, scalar multiplication is defined as follows:

Finally, we can check for vector equality by comparing each component of the vectors being tested. Two vectors are the same only if all of their components are equal.

We're going to implement all of the preceding component-wise operations by overloading the appropriate C++ operators. All of the operators presented in this section can be overloaded in C# as well. In languages that do not support operator overloading, you will have to make these into regular functions.

### How to do it…

Follow these steps to override common operators for the vector class. This will make working with vectors feel more intuitive:

1. In `vectors.h`, add the following function declarations:

```vec2 operator+(const vec2& l, const vec2& r);
vec3 operator+(const vec3& l, const vec3& r);
vec2 operator-(const vec2& l, const vec2& r);
vec3 operator-(const vec3& l, const vec3& r);
vec2 operator*(const vec2& l, const vec2& r);
vec3 operator*(const vec3& l, const vec3& r);
vec2 operator*(const vec2& l, float r);
vec3 operator*(const vec3& l, float r);
bool operator==(const vec2& l, const vec2& r);
bool operator==(const vec3& l, const vec3& r);
bool operator!=(const vec2& l, const vec2& r);
bool operator!=(const vec3& l, const vec3& r);```
2. Create a new C++ source file, `vectors.cpp`. Include the following headers in the new file:

```#include "vectors.h"
#include <cmath>
#include <cfloat>```
3. Add a macro for comparing floating point numbers to `vectors.cpp`:

```#define CMP(x, y)                    \
(fabsf((x)–(y)) <= FLT_EPSILON * \
fmaxf(1.0f,                    \
fmaxf(fabsf(x), fabsf(y)))     \
)```
4. Add the implementation of vector addition to the `vectors.cpp` file:

```vec2 operator+(const vec2& l, const vec2& r) {
return { l.x + r.x, l.y + r.y };
}

vec3 operator+(const vec3& l, const vec3& r) {
return { l.x + r.x, l.y + r.y, l.z + r.z };
}```
5. Add the implementation of vector subtraction to the `vectors.cpp` file:

```vec2 operator-(const vec2& l, const vec2& r) {
return { l.x - r.x, l.y - r.y };
}

vec3 operator-(const vec3& l, const vec3& r) {
return { l.x - r.x, l.y - r.y, l.z - r.z };
}```
6. Add the implementation for vector multiplication to the `vectors.cpp` file:

```vec2 operator*(const vec2& l, const vec2& r) {
return { l.x * r.x, l.y * r.y };
}

vec3 operator*(const vec3& l, const vec3& r) {
return { l.x * r.x, l.y * r.y, l.z * r.z };
}```
7. Add the implementation for scalar multiplication to the `vectors.cpp` file:

```vec2 operator*(const vec2& l, float r) {
return { l.x * r, l.y * r };
}

vec3 operator*(const vec3& l, float r) {
return { l.x * r, l.y * r, l.z * r };
}```
8. Finally, add the implementation for vector equality to the `vectors.cpp` file. This is where the compare macro we created in step 3 comes in:

```bool operator==(const vec2& l, const vec2& r) {
return CMP(l.x, r.x) && CMP(l.y, r.y);
}

bool operator==(const vec3& l, const vec3& r) {
return CMP(l.x, r.x) && CMP(l.y, r.y) && CMP(l.z, r.z);
}

bool operator!=(const vec2& l, const vec2& r) {
return !(l == r);
}

bool operator!=(const vec3& l, const vec3& r) {
return !(l == r);
}```

### How it works…

What these components-wise operations are doing might not be obvious from the definitions and code provided alone. Let's explore the component-wise operations of vectors visually.

Every vector describes a series of displacements. For example, the vector (2, 3) means move two units in the positive X direction and three units in the positive Y direction. We add vectors by following the series of displacements that each vector represents. To visualize this, given vectors and , draw them so the head of touches the tail of The result of the addition is a new vector spanning from the tail of to the head of :

#### Subtraction

Subtraction works the same way as addition. We have to follow the negative displacement of vector starting from vector . To visually subtract vectors and , draw and with their tails touching. The result of the subtraction is a vector spanning from the head of to the head of :

A more intuitive way to visualize subtraction might be to think of it as adding negative to, like so; . If we represent the subtraction like this, visually we can follow the rules of addition:

In the above image, the vector appears multiple times. This is to emphasize that the position of a vector does not matter. Both of the vectors above represent the same displacement!

#### Multiplication (Vector and Scalar)

Multiplying a vector by a scalar will scale the vector. This is easy to see when we visualize the result of a multiplication. The scalar multiplication of a vector will result in a uniform scale, where all components of the vector are scaled by the same amount. Multiplying two vectors on the other hand results in a non-uniform scale. This just means that each component of the vector is scaled by the corresponding component of the other vector:

#### Comparison

Comparing vectors is a component-wise operation. If every component of each vector is the same, the vectors are equal. However, due to floating point error we can't compare floats directly. Instead, we must do an epsilon comparison. Epsilon tests commonly fall in one of two categories: absolute tolerance and relative tolerance:

```#define ABSOLUTE(x, y) (fabsf((x)–(y)) <= FLT_EPSILON)
#define RELATIVE(x, y) \
(fabsf((x) – (y)) <= FLT_EPSILON * Max(fabsf(x), fabsf(y)))```

The absolute tolerance test fails when the numbers being compared are large. The relative tolerance test fails when the numbers being compared are small. Because of this, we implemented a tolerance test with the `CMP` macro that combines the two. The logic behind the `CMP` macro is described by Christer Ericson at www.realtimecollisiondetection.net/pubs/Tolerances.

### There's more…

It's desirable to make vectors easy to construct in code. We can achieve this by adding default constructors. Each vector should have two constructors: one that takes no arguments and one that takes a float for each component of the vector. We do not need a copy constructor or assignment operator as the `vec2` and `vec3` structures do not contain any dynamic memory or complex data. The pair of constructors for the `vec2` structure will look like this:

```vec2() : x(0.0f), y(0.0f) { }
vec2(float _x, float _y) : x(_x), y(_y) { }```

The `vec3 `constructors will look similar, it adds an additional component. The constructors for the `vec3` structure will look like this:

```vec3() : x(0.0f), y(0.0f), z(0.0f) { }
vec3(float _x, float _y, float _z) : x(_x), y(_y), z(_z) { }```