Computer Graphics (CS 543) 

Lecture 4 (Part 3): Viewing & Camera 
Control

Prof Emmanuel Agu
Computer Science Dept.
Worcester Polytechnic Institute (WPI)
 3D Viewing?
 Objects inside view volume show up on screen
 Objects outside view volume clipped!
2. Set view volume
(3D region of interest)
1. Set camera position
Different View Volume Shapes 

y y
z z

x x

Perspective view volume

Orthogonal view volume

 Different view volume => different look
 Foreshortening? Near objects bigger
 Perpective projection has foreshortening
 Orthogonal projection: no foreshortening
The World Frame
 Objects/scene initially defined in world frame
 Objects positioned, transformations (translate, scale, 
rotate) applied to objects in world frame

World frame
(Origin at 0,0,0)
 Camera Frame
 More natural to describe object positions relative to camera (eye)
 Think about 
 Our view of the world
 First person shooter games
 Camera Frame
 Viewing: After user sets camera (eye) position, represent objects 
in camera frame (origin at eye position)
 Viewing transformation:  Changes object positions from world 
frame to positions in camera frame using model‐view matrix

World frame
(Origin at 0,0,0)

Camera frame
(Origin at camera)
 Default OpenGL Camera
 Initially Camera at origin: object and camera frames same
 Camera located at origin and points in negative z direction
 Default view volume is cube with sides of length 2

Default view volume clipped out

(objects in volume 2
are seen)

z=0
Moving Camera Frame
Same relative distance after
Same result/look

Translate objects +5  Translate camera ‐5 
away from camera away from objects
default frames
 Moving the Camera
 We can move camera using sequence of rotations 
and translations
 Example: side view
 Rotate the camera
 Move it away from origin
 Model‐view matrix C = TR

// Using mat.h

mat4 t = Translate (0.0, 0.0, -d);

mat4 ry = RotateY(90.0);
mat4 m = t*ry;
 Moving the Camera Frame
 Object distances relative to camera determined by the 
model‐view matrix
 Transforms (scale, translate, rotate) go into modelview matrix
 Camera transforms also go in modelview matrix (CTM)

Rotate
Camera Scale
Transforms Translate

CTM
The LookAt Function
 Previously, command gluLookAt to position camera
 gluLookAt deprecated!!
 Homegrown mat4 method LookAt() in mat.h
 Can concatenate with modeling transformations

void display( ){
………

mat4 mv = LookAt(vec4 eye, vec4 at, vec4 up);

……..
}
 LookAt
LookAt(eye, at, up)

But Why do we set 
Up direction?

Programmer defines: 
• eye position 
• LookAt point (at) and 
• Up vector (Up direction usually (0,1,0))
Nate Robbins LookAt Demo
What does LookAt do?
 Programmer defines eye, lookAt and Up
 LookAt method: 
 Form new axes (u, v, n) at camera 
 Transform objects from world to eye camera frame
World coordinate
Frame

Eye coordinate
Frame
 Camera with Arbitrary Orientation 
and Position
 Define new axes (u, v, n)  at eye
 v points vertically upward, 
 n away from the view volume,  World coordinate
Frame (old)
 u at right angles to both n and v.  
 The camera looks toward ‐n.  
 All vectors are normalized.

Eye coordinate
Frame (new)
LookAt: Effect of Changing Eye Position 
or LookAt Point
 Programmer sets LookAt(eye, at, up)
 If eye, lookAt point changes => u,v,n changes
Viewing Transformation Steps
1. Form camera (u,v,n) frame
2. Transform objects from world frame (Composes matrix 
for coordinate transformation)

 Next, let’s form camera (u,v,n) frame

(0,1,0) (1,0,0)
v u
n (0,0,1)
y
(0,0,0)
lookAt
world x
z
 Constructing U,V,N Camera Frame 
 Lookat arguments: LookAt(eye, at, up)
 Known: eye position, LookAt Point, up vector
 Derive: new origin and three basis (u,v,n) vectors  

Lookat Point
eye
o
90
 Eye Coordinate Frame
 New Origin: eye position (that was easy)
 3 basis vectors: 
 one is the normal vector (n) of the viewing plane, 
 other two (u and v) span the viewing plane
n is pointing away from the
v world because we use left
u
hand coordinate system
Lookat Point
eye N = eye – Lookat Point
n n= N / |N|

world origin Remember u,v,n should

be all unit vectors
(u,v,n should all be orthogonal)
Eye Coordinate Frame

 How about u and v?
V_up •We can get u first -
v u •u is a vector that is perp
to the plane spanned by
Lookat N and view up vector (V_up)
eye
n

U = V_up x n

u = U / |U|
Eye Coordinate Frame
 How about v?

V_up
v u Knowing n and u, getting v
is easy
Lookat
eye
n v = n xu

v is already normalized
Eye Coordinate Frame
Eye space origin: (Eye.x , Eye.y,Eye.z)

 Put it all together Basis vectors:

n = (eye – Lookat) / | eye – Lookat|

u = (V_up x n) / | V_up x n |
V_up v = n x u
v u

Lookat
eye
n
Step 2: World to Eye Transformation

 Next, use u, v, n to compose LookAt matrix 
 Transformation matrix (Mw2e) ? 
P’ =  Mw2e x  P  
v u 1. Come up with transformation
y sequence that lines up eye frame
P n with world frame
Eye
world frame 2. Apply this transform sequence to
point P in reverse order
x

z
 World to Eye Transformation
1. Rotate eye frame to “align” it with world frame 
2. Translate (‐ex, ‐ey, ‐ez) to align origin with eye

Rotation: ux uy uz 0
v vx vy vz 0
u nx ny nz 0
y n 0 0 0 1

(ex,ey,ez)
world
x Translation: 1 0 0 -ex
0 1 0 -ey
0 0 1 -ez
z 0 0 0 1
 World to Eye Transformation
 Transformation order: apply the transformation to the 
object in reverse order ‐ translation first, and then rotate 
Rotation Translation
ux uy ux 0 1 0 0 -ex
Mw2e =
vx vy vz 0 0 1 0 -ey
nx ny nz 0 0 0 1 -ez
0 0 0 1 0 0 0 1
v u
y n ux uy uz -e . u
Multiplied together
(ex,ey,ez) vx vy vz -e . v
=
= lookAt transform
world nx ny nz -e . n
x 0 0 0 1
z
Note: e.u = ex.ux + ey.uy + ez.uz
 lookAt Implementation (from mat.h)
Eye space origin: (Eye.x , Eye.y,Eye.z)
ux uy uz -e . u
Basis vectors:
vx vy vz -e . v
n = (eye – Lookat) / | eye – Lookat| nx ny nz -e . n
u = (V_up x n) / | V_up x n | 0 0 0 1
v = n x u

mat4 LookAt( const vec4& eye, const vec4& at, const vec4& up )
{
vec4 n = normalize(eye - at);
vec4 u = normalize(cross(up,n));
vec4 v = normalize(cross(n,u));
vec4 t = vec4(0.0, 0.0, 0.0, 1.0);
mat4 c = mat4(u, v, n, t);
return c * Translate( -eye );
}
 References
 Interactive Computer Graphics, Angel and Shreiner, 
Chapter 4
 Computer Graphics using OpenGL (3rd edition), Hill 
and Kelley