#### 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

## Magnitude

The magnitude or length of a vector is written as the letter of the vector surrounded by two bars, . The magnitude of a vector is the square root of the dot product of the vector with itself:

In addition to implementing the magnitude function, we're also going to implement a magnitude squared function. The formula is the same, but it avoids the expensive square root operation:

In games we often compare the magnitude of a vector to known numbers; however, doing a comparison between a number and the magnitude is expensive because of the square root operation. A simple solution to this problem is to square the number, and then compare against square magnitude. This means, instead of the following:

`if (Magnitude(someVector) < 5.0f) {`

We could instead write the following:

`if (MagnitudeSq(someVector) < 5.0f * 5.0f) {`

We'd then get the same result, avoiding the expensive square root operation.

To find the magnitude of a vector, take the square root of the vector's dot product with its-self. The square root operation is a relatively expensive one that should be avoided whenever possible. For this reason, we are also going to implement a function to find the square magnitude of a vector.

### How to do it…

Follow these steps to implement a function for finding the length and squared length of two and three dimensional vectors.

1. Add the declaration for magnitude and magnitude squared to `vectors.h`:

```float Magnitude(const vec2& v);
float Magnitude(const vec3& v);

float MagnitudeSq(const vec2& v);
float MagnitudeSq(const vec3& v);```
2. Add the implementation for these functions to `vectors.cpp`:

```float Magnitude(const vec2& v) {
return sqrtf(Dot(v, v));
}

float Magnitude(const vec3& v) {
return sqrtf(Dot(v, v));
}

float MagnitudeSq(const vec2& v) {
return Dot(v, v);
}

float MagnitudeSq(const vec3& v) {
return Dot(v, v);
}```

### How it works…

We can derive the equation for the magnitude of a vector from the geometric definition of the dot product that we briefly looked at in the last section:

Because we are taking the dot product of the vector with itself, we know the test vectors point in the same direction; they are co-directional. Because the vectors being tested are co-directional, the angle between them is 0. The cosine of 0 is 1, meaning the part of the equation can be eliminated, leaving us with the following:

If both the test vectors are the same (which in our case they are) the equation can be written using only :

We can rewrite the preceding equation, taking the square root of both sides to find the length of vector :

### There's more…

The magnitude of a vector can be used to find the distance between two points. Assuming we have points and , we can find a vector () that connects them by subtracting from , as shown in the following diagram:

The distance between the two points is the length of . This could be expressed in code as follows:

```float Distance(const vec3& p1, const vec3& p2) {
vec3 t = p1 - p2;
return Magnitude(t);
}```