Quaternions

Paul Taylor 2010

Swizzle

• What is a swizzle?

Matrix Rotations

• A simple 2D (xy) Rotation Matrix:

• Rotates in the xy plane counterclockwise by Ɵ Degrees ( In a RH Space)

• The Determinant is always 1

http://en.wikipedia.org/wiki/Rotation_matrix

3D Rotations

• Rx rotates Y towards Z• Ry rotates Z towards X• Rz rotates X towards Y

http://en.wikipedia.org/wiki/Rotation_matrix#Rotations_in_two_and_three_dimensions

Euler Angles (Yaw Pitch Roll)

Pros: Easy to visualiseCons: Gimbal LockIf any one axis is exactly 0 or PI or –PI(Where Cos Ɵ = 1 and Sin Ɵ = 0)The freedom of rotation is limited to a plane.

Rotation about an Axis

• U is a unit vector specifying the rotation plane

• C = Cos Ɵ• S = Sin Ɵ

http://en.wikipedia.org/wiki/Rotation_matrix#Rotations_in_two_and_three_dimensions

The quaternion solution

Q Quaternion is a 4-tuple of numbers, typically called (s, x, y, z)

S acts as a scalar, and xyz act as a 3D vectorThe vector xyz should satisfy X2 + Y2 + Z2 = XYZ = -1 Where s2 + X2 + Y2 + Z2 = 1 the quaternion can be

considered a rotation.

Quaternion Addition

Quaternion Subtraction

Quaternion Multiplication

Quaternion Division

• Don’t divide by Zero!

Quaternion Advantages

StorageMatrix must be at minimum 3x3 typically stored

as a 4x4.A quaternion may be stored as 4 values.Chaining (preparing) an xyz rotation:

Method # multiplies # add/subtracts

total operations

Rotation matrices

27 18 45Quaternions 16 12 28

• Performing an xyz Rotation

Method # multiplies

# add/subtracts

# sin/cos total operations

Rotation matrix

9 6 0 15Quaternions

21 18 0 39Angle/axis 23 16 2 41

Smooth rotation interpolation

• Ideal for animation• LERPING between one rotation and a second

will take the shortest path using a quaternion

Collision Detection

• What is it?

• What does it need to be?– Precise– Efficient– Fast

What collides?

• Almost everything• This would result in roughly n2 different

collisions to detect each frame.

Cheating the system

• We CAN mathematically check every single polygon against every other.

• Just not in this lifetime!

Bounding Spheres

• Collision if r1 + r2 < distance from P1 to P2

http://www.gamasutra.com/view/feature/3190/advanced_collision_detection_.php?page=2

Bounding Boxes

• Axis Aligned (AABB)– This allows for compatibility with oct trees, and

extreme simplification of intersections• Oriented (OBB)– These will fit strange objects better– Only need to be created once– Much more complex to intersect

A strange object

Bounding Trees

• We can create a small tree to bound a stupid object.– These must be built offline– Each vertex must be matrix multiplied into the

world, so things will start to get expensive

The Separating Axis Theorem

• This theorem allows for collision detection utilising separating axis’ is 2D

• It dumbs down to the ability to put a line between the two objects.

• This extends to 3D using aseparating plane

Convex Only!!!

Stationary Objects

• Do not move, so we do not have to detect collisions by the object, only on the object!

BSP Trees and Collisions

• Using Cartesian plane equations and the vertices of our object BSP intersections are extremely quick.

• ax + by + cz + d = 0• ax + by + cz + d > 0 positive side of the BSP

polygon• ax + by + cz + d < 0 negative side of the BSP

polygon

Size == Time step

• A small object will need a smaller change in time to detect collisions.

• How can you make this work?• The two special cases:– Small vs Small object (both high

resolution)– Small vs large object (large is at a low

resolution)

http://www.gamasutra.com/view/feature/3190/advanced_collision_detection_.php?page=2

Bezier Curve Collisions• We can use the Convex Hull Property for coarse

collision detection• This extends to 3D easily.• For more accurate collisions you will need to do

something like Cartesian plane equations, by calculating the plane at points on the curve

• Tessellation into polygons remains the most common approach

For only low detail Bezier collisions...

• We can use a vastly simplified polygon surface• This is useless as a basis for a high accuracy collision

detection algorithm, as it will reject some collisions

http://www.gamasutra.com/view/feature/3190/advanced_collision_detection_.php?page=3

Per-Pixel Collision Detection

• The Atari had built-in collision detection in the video chip, this made collisions extremely simple

• Can we do something similar today?

GPU Based Collision Detection

• There is a bit of research in this area– GPU only solutions– CPU-GPU hybrids

Direction Based Collision Trees

• What if we only consider colliding with objects in the direction that the focus object is travelling?

• Calculating the Normal Plane for the rear-most point would give us an instant cull of many objects

A Solid BSP Tree Tutorial

• http://www.gamedev.net/reference/articles/article657.asp

Advanced Collision Detection

• http://www.realtimerendering.com/intersections.html

• This is a great table for finding algorithms

Specular Lighting

• This is the light that an object reflects into the viewers eye

• For this we will need to add a few more variables to our light system

http://prosjekt.ffi.no/unik-4660/lectures04/chapters/jpgfiles/specular.jpg

http://www.baylee-online.net/Projects/Raytracing/Algorithms/Glossy-Reflection-Transmission

Creating a cone

• A modified version of Lambert’s Cosine law is implemented, giving an easily controlled and calculated light cone.

“the radiant intensity observed from a "Lambertian" surface is directly proportional to the cosine of the angle θ between the observer's line of sight and the surface normal.” - Wikipedia

So the intensity of the light drops off as the angle increases.

• Light intensity = cos()n • n is an exponent which changes the speed of

the falloff for a specular highlight.• A high n will create a very sharp reflection

through a small cone• A low n (n is always >=1) will create a much

broader cone of reflection.

Creating a conehttp://fooplot.com/

The new variables

• View (eye) PositionWe generate a vector from the surface point to

the eye:toEye = view – vertex.position;toEye = Normalize(toEye);

The new jobs:specularPower = vertex.specular.a // a = power// Minimum of 1.0fspecularPower = max(specularPower, 1.0f);Float3 reflection = reflect(light.vector, vertex.normal);specularFactor = dot(reflection, toEye);// No specular if light is behindspecularFactor = max(specularFactor, 0.0f);// Now we add the exponentspecularFactor = pow(specularFactor, specularPower);light += specularFactor * vertex.specular * light.specular;Return light;

Starcraft 2

http://www.gamasutra.com/view/news/28433/Blizzard_Reveals_StarCraft_II_Subscription_Option_For_Emerging_Markets.php