Game Physics Cookbook
This book is a comprehensive guide to the linear algebra and collision detection games commonly use, but only briefly touches on the topic of collision resolution (Physics). The book is structured as follows:
 Chapters 1, 2 and 3 cover the basics Linear Algebra.
 Chapters 4, 5 and 6 cover two dimensional primitives and how to detect intersections between them.
 Chapters 7, 8, 9 and 10 cover three dimensional primitives and the most efficient way to determine intersections between them.
 Chapters 11, 12 and 13 cover meshes, scenes and scene organization.
 Chapters 14, 15 and 16 cover physics. Throughout these three chapters we built a very basic rigid body physics engine.
All of of the topics covered in this book are used to progressivley build a rigid body physics engine. The final three chapters (14, 15 and 16) implement particle physics, rigid body physics and soft body physics (cloth). An appendinx is provided which briefly covers advanced topics, resources for exploring these topics as well as additional resources for exploring game physics.
Figures
Some of the figures created for the book did not translate well to print. To address this I have included the all of the book figures in this repository and published the figures online at: https://github.com/gamephysicscookbook/Figures
Math
The first three chapters of the book are dedicated to teaching the basic linear algebra needed for game development. Every concept is explained in a mathematical context, source code is provided for every concept and images are also provided when something can be explored visually. Troughout the first three chapters the following data structures are created:
 2 dimensional vector (
vec2
)  3 dimensional vector (
vec3
)  2x2 matrix (
mat2
)  3x3 matrix (
mat3
)  4x4 matrix (
mat4
)
When possible, matrix operations are implemented in a generic way. For example, code is provided to multiply two matrices of arbitrary sizes together.
Collision Detection
The following intersections are covered in the book:
Point  Line  Ray  Sphere  AABB  OBB  Plane  Triangle  Frustum  

Point  
Line  
Ray  
Sphere  
AABB  
OBB  
Plane  
Triangle  
Frustum 
Physics
Chapter 14 covers naive particle physics, this chapter is meant as an introduction to setting up a physics loop and considering the general format of a physics loop. Chapter 15 is the most interesting chapter, it implements a basic rigid body physics engine. The basic engine has support for oriented boxes and spheres, stacking can be made to work but is not directly supported. Chapter 16 covers springs and how springs can be used to implement soft body physics. The final demo of the book is a soft body, cloth physics demo.
Learnings
This being my first book, I've learned a lot about the writing process; perhaps even more about planning. The following is a list of things I've discovered while writing this book that I did not plan properly for:

Quaternions: Having a quaternion is a must! I planned to write the book using euler rotations and rotation matrices. While this worked, having access to quaternions would have made life a lot easyer.

Planes: Plane intersections should not return a boolean value, they should classify the intersection as: behind, intersecting, in front. Preferably, if the intersection is in front or behind, you want to return some indication of distance. This becomes very useful when doing Frustum culling. I didn't know how indepth i was going to write about frustums, so i decided to do simple boolean intersectiosn.

Raycasting: I should have written raycasts to return a raycast result from the beginning. Having to later go back and rewrite the raycasting API turned out to be more complicated to express in text than i anticipated. The tought behind this was to keep things simple at first, complicate only as needed.
Issues
There are various issues in the physics implementation of the source code. These issues come from the fact that the physics part of this book had to be condensed into three chapters. There was just not enough time to cover everything needed to make a robust rigidbody physics system. The biggest problem with the engine is the fact that there is no Arbiter.
Without an arbiter, we can't build a sequential impulse solver. This leaves us with a rather barebones naive impulse solver. The problem is, impulses are solved per contact per frame. This causes excessive sliding. I've compensated for the lack of sequential impulse with linear projection and agressive friciton biasing. Older physics engines do something similar, by relying on strong handed sleeping to mask the issue. Needless to say, sleeping was not implemented.
Future
If I have a chance to write a second edition of this book, i will remove the chapters on two dimensional collisions (chapters 4, 5 and 6) and cut down the page count of the scene management chapters. I plan to use the extra pages to cover the following topics:
 In depth discussion and implementation of GJK
 A proper arbiter system and a more stable collision resolution model.
 Capsule primitive
 Convex hull generation and collision testing
Book Info
 ISBN13: 9781787123663
 View at Packt
 View on Amazon
 All my publications
Table Of Contents
 Vectors
 Introduction
 Vector definition
 Component wise operations
 Dot product
 Magnitude
 Normalizing
 Cross product
 Angles
 Projection
 Reflection
 Matrices
 Introduction
 Matrix definition
 Transpose
 Multiplication
 Identity matrix
 Determinant of a 2x2 matrix
 Matrix of minors
 Cofactor
 Determinant of a 3x3 matrix
 Operations on a 4x4 matrix
 Adjugate matrix
 Matrix inverse
 Matrix Transforms
 Introduction
 Matrix majors
 Translation
 Scaling
 How rotations work
 Rotation matrices
 Axis angle rotation
 Vector matrix multiplication
 Transform matrix
 Projection matrix
 2D Primitive Shapes
 Introduction
 2D points
 2D lines
 Circle
 Rectangle
 Oriented rectangle
 Point containment
 Line intersection
 2D Collisions
 Introduction
 Circle to circle
 Circle to rectangle
 Circle to oriented rectangle
 Rectangle to rectangle
 Seperating Axis Theorem
 Rectangle to oriented rectangle
 Oriented rectangle to oriented rectangle
 2D Optimizations
 Introduction
 Containing circle
 Containing rectangle
 Simple and complex shapes
 Quad tree
 Broad phase collisions
 3D Primitive Shapes
 Introduction
 Point
 Line segment
 Ray
 Sphere
 Axis aligned bounding box
 Oriented buonding box
 Plane
 Triangle
 3D Point Tests
 Introduction
 Point and sphere
 Point and axis aligned bounding box
 Point and oriented bounding box
 Point and plane
 Point and line
 Point and ray
 3D Shape Intersections
 Introduction
 Sphere to sphere
 Sphere to axis aligned bounding box
 Sphere to oriented bounding box
 Sphere to plane
 Axis aligned bounding box to axis aligned bounding box
 Axis aligned bounding box to oriented bounding box
 Axis aligned bounding box to plane
 Oriented bounding box to oriented bounding box
 Oriented bounding box to plane
 Plane to plane
 3D Line Intersections
 Introduction
 Raycast sphere
 Raycast axis aligned bounding box
 Raycast oriented bounding box
 Raycast plane
 Linetest sphere
 Linetest axis aligned bounding box
 Linetest oriented bounding box
 Linetest plane
 Triangles and Meshes
 Introduction
 Point in triangle
 Closest point triangle
 Triangle to sphere
 Triangle to axis aligned bounding box
 Triangle to oriented box
 Triangle to plane
 Triangle to triangle
 robustness of the seperating axis theorem
 Raycast triangle
 Linetest triangle
 Mesh object
 Mesh optimization
 Mesh operations
 Models and Scenes
 Introduction
 The model object
 Operations on models
 The scene object
 Operations on the scene
 The octree object
 Operations on the octree
 Octree and scene integration
 Camera and Frustum
 Introduction
 Camera object
 Camera controls
 Frustum object
 Frusum from matrix
 Sphere in frustum
 Bounding box in frustum
 Octree culling
 Picking
 Constraint Solving
 Introduction
 Framework introduction
 Raycast sphere
 Raycast bounding box
 Raycast plane and triangle
 Physics system
 Integrating particles
 Solving constraints
 Verlet integration
 Manifolds and Impulses
 Introduction
 Manifold for spheres
 Manifold for boxes
 Rigid body modifications
 Linera velocity
 Linear impulse
 Physics system update
 Angular velocity
 Angular impulse
 Sprints and Joints
 Introductions
 Particle modifications
 Springs
 Cloth
 Physics System modification
 Joints
 Appendix: Advanced Topics
 Introduction
 Generic collisions
 Stability improvements
 Sprints
 Open source physics engines
 Books
 Online resources
 Summary