CO3303-1 Lecture 2.ppt

Maths and Technologies for Games
Quaternions
CO3303
Week 1

• We have used two methods to store a rotation:
Representing Rotations
2. Three Euler/Fixed angles:
– X, Y & Z, (or yaw, pitch & roll)
– Can be combined in any order
– Used in TL-Engine
[See Van Verth for more detail]












1
0
0
0
0
0
0
z
y
x
z
y
x
z
y
x
Z
Z
Z
Y
Y
Y
X
X
X
1. A matrix:
– Can just use 3x3 matrix
for rotation
– Used these in DirectX

Converting between Formats
• We can create a matrix from fixed angles
– Create a rotation matrix for each angle:
– E.g. Z rotation matrix of α:
• Multiply the matrices together: M = RX*RY*RZ
– Different results for different multiplication orders
• Can also convert matrix back to fixed angles
– See Van Verth or the matrix class in the labs














1
0
0
0
0
1
0
0
0
0
cos
sin
0
0
sin
cos




Z
R

Euler Angles – Pros/Cons
• Concise storage – just three floats
• Euler/Fixed angles seem intuitive
– But which order to multiply when forming a matrix?
– Different orders in same app can cause problems
• Are the rotations world or local rotations?
– Depends on order again
• Gimbal lock can occur when one angle is 90°
– The other angles interfere with each other, result is ambiguous
– E.g. causing strange spinning effects when looking straight up or
down (you will have seen this problem in some games)

Matrices – Pros/Cons
• Unambiguous definition of rotation
– As compared to Euler angles
• 4x4 matrix can also hold position and scale
– And totally different things: projection matrix
• Used by graphics hardware
– Must convert all forms to matrices eventually
• But uses 16 floats
– Much processing/storage even for simple operations
• Can be stored in two ways, by row or by column
– APIs (DirectX) and maths texts use different forms

Axis-Angle Rotations
• Look for other ways to specify rotations…
• Can specify any rotation as a rotation axis r (a vector)
and an angle θ (a scalar):
• Can convert to and from matrices
(see Van Verth or matrix class)
• Useful way to think about rotation
• But operations are generally
complex with this form
– Including interpolation (see later)

Quaternions
• Quaternions can be used to represent rotation
• A general quaternion takes the form:
– We will use these forms interchangeably
• We will mostly consider normalised quaternions:
• However, several quaternion formulae result in un-
normalised quaternions
– Often need to renormalise quaternions before reuse
)
,
,
(
where
)
,
(
or
)
,
,
,
(
z
y
x
w
z
y
x
w



v
v
q
q
1
where 2
2
2
2



 z
y
x
w
= examinable

Quaternions
• A quaternion is a form of axis-angle rotation
– When in a normalised form
• If we rewrite a quaternion in this form:
• Then r and θ form an axis-angle
rotation as described before:
– r is a unit vector here
)
)
2
/
sin(
),
2
/
(cos(
)
,
( r
v
q 


 w

Quaternions – Pros/Cons
• Why use this more complex variation on angle-axis form?
• Because quaternions can easily be:
– Combined together
– Used to transform points/vectors
– Quaternions can be interpolated easily
• A feature vital for animation, which is more difficult with matrices
• Quaternions only use 4 floats for storage
• However, they lack hardware support
– So we need to convert them to and from matrices

Quaternion Formulae 1
• A quaternion can be converted to a matrix:
– A little expensive, can be simplified in code
– Transposed from Van Verth book for row-based system (DirectX / math
text difference)
• Reverse conversion is also possible (see Van Verth)
• Quaternions don’t convert easily to Euler angles
normalised
not
is
if
1
by
result
multiply
1
0
0
0
0
2
2
1
2
2
2
2
0
2
2
2
2
1
2
2
0
2
2
2
2
2
2
1
then
,
)
,
,
,
(
If
2
2
2
2
2
2
2
2
2
2
q
M
q
q
z
y
x
w
y
x
wx
yz
wy
xz
wx
yz
z
x
wz
xy
wy
xz
wz
xy
z
y
z
y
x
w
































• Quaternions can be added and scaled:
– Scaling is used for normalisation
• Two quaternions can be multiplied to create a single
quaternion performing both rotations:
– Same effect as multiplying matrices, order important
– Coded efficiently this is faster than matrix multiplication
– N.B. Swapped multiplication order from text for row-based system
)
,
,
,
(
)
,
,
,
(
)
,
,
,
( 2
1
2
1
2
1
2
1
2
2
2
2
1
1
1
1 z
z
y
y
x
x
w
w
z
y
x
w
z
y
x
w 





)
,
,
,
(
)
,
,
,
( az
ay
ax
aw
z
y
x
w
a 
)
,
(
)
,
( 1
2
2
1
2
1
2
1 v
v
v
v
v
v
v
q
q 1
2
2
1 





 w
w
w
w
w

• Inverse of a quaternion (the rotation in the opposite
direction) is simple:
– Assumes quaternion is normalised
– Much faster than matrix equivalent, which can be complex
• We can also represent vectors as quaternions
– Just set w = 0:
)
,
(
1
v
q 


w
quaternion
a
as
)
,
,
,
0
(
)
,
,
(
Vector z
y
x
z
y
x 

p

• Rotate a vertex or vector p by a quaternion q=(w,v):
– Slower than matrix equivalent
– 1st formula reversed for row-based system (2nd remains same)
– N.B. The formula in earlier Van Verth edition is incorrect
• Derivation of most formulae in Van Verth
– As well as further detail
pq
q
p 1
q


)
(
Rotate
)
(
2
)
(
2
)
1
2
( 2
p
v
v
p
v
p 




 w
w

Quaternions: Initial Summary
• Quaternions can perform similar operations to matrices
– With comparable performance
– But need to convert to / from matrices
– And can’t store position / scaling
• No compelling reason to use them yet
• But next week we will see how quaternions compare to
matrices for interpolation
– And how this is used this for animation

CO3303-1 Lecture 2.ppt

More Related Content

Similar to CO3303-1 Lecture 2.ppt (20)

Recently uploaded (20)

CO3303-1 Lecture 2.ppt