a camera class for opengl l.
Skip this Video
Loading SlideShow in 5 Seconds..
A Camera Class for OpenGL PowerPoint Presentation
Download Presentation
A Camera Class for OpenGL

Loading in 2 Seconds...

play fullscreen
1 / 33

A Camera Class for OpenGL - PowerPoint PPT Presentation

  • Uploaded on

A Camera Class for OpenGL. John McGuiness October 2006. Necessity for a Camera Class. Existing available camera tool - gluLookAt() Basic utility which encapsulates a series of rotate and translate commands Allows viewing along an arbitrary line of sight with an “Up” vector defined

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about 'A Camera Class for OpenGL' - hal

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
a camera class for opengl

A Camera Class for OpenGL

John McGuiness

October 2006

necessity for a camera class
Necessity for a Camera Class
  • Existing available camera tool - gluLookAt()
    • Basic utility which encapsulates a series of rotate and translate commands
    • Allows viewing along an arbitrary line of sight with an “Up” vector defined
  • Need extra transformations to provide greater flexibility
  • Need to modify “Forward” and “Along” vectors as well as “Up” to improve on gluLookAt()
  • Camera class may be built to encapsulate commands for greater ease of use
up forward and along
“Up”, “Forward” and “Along”
  • The three camera view vectors are defined as shown:
proposed camera features
Proposed Camera Features
  • The camera class should:
    • Provide motion along the view vectors as well as arbitrary axes (in some cases)
    • Provide rotation about the view vectors as well as arbitrary axes (in some cases)
    • Maintain the camera’s own orientation by keeping the viewing vectors orthogonal to each other
  • Need to define motion for two possible types of camera:
    • Land camera – e.g. for road vehicles simulation
    • Air camera – e.g. for flight simulation
camera motion
Camera Motion
  • Walking
    • This is motion along the Forward vector (or Z-axis):
camera motion6
Camera Motion
  • Strafing
    • This is side to side motion on the Along vector (or X-axis):
camera motion7
Camera Motion
  • Flying
    • This is vertical motion on the Up vector (or Y-axis):
camera rotation

This is rotation about the Along vector – looking up and down

Camera Rotation
camera rotation9

This is rotation about the Up vector – looking left and right

Camera Rotation
camera rotation10

This is rotation about the Forward vector – twisting left and right

Camera Rotation
camera class declaration
Camera Class Declaration
  • The camera class uses a type called Vector3D which provides storage and common operations (e.g. dot product, cross product etc.) for vectors

#include "Vector3D.h"

  • The enumerated type defined below is used to distinguish between the two types of camera


camera class declaration12
Camera Class Declaration
  • First, we need private variables for each view vector as well as the camera type and current position:

class Camera {


CAM_TYPE CameraType;

Vector3D Position;

Vector3D Along;

Vector3D Up;

Vector3D Forward;


camera class declaration13
Camera Class Declaration
  • Various construction/destruction, update and control functions are then declared publically:

class Camera {



Camera(CAM_TYPE ct = LAND_CAM); // Default: land

virtual ~Camera();

void SetCameraType(CAM_TYPE ct);

Vector3D GetPosition();

void Reset();

void Update();


camera class declaration14
Camera Class Declaration
  • Finally, the motion and rotation functions are declared.
  • The boolean array, Wall[4], is an extra feature which modifies the motion of land cameras if they have to slide against walls (as opposed to going through them)

class Camera {




void Pitch(GLfloat theta);

void Yaw(GLfloat theta);

void Roll(GLfloat theta);

void Walk(GLfloat delta, bool Wall[4]);

void Strafe(GLfloat delta, bool Wall[4]);

void Fly(GLfloat delta);


setup and control functions
Setup and Control Functions
  • The code listing on the following two slides is fairly self-explanatory
  • It comprises the basic constructor and destructor as well as a function to alter the camera type
  • The Reset() function sets the camera position to (0,0,0) and aligns the viewing axes with the local drawing coordinate system
  • Note that the default Forward vector points along the negative Z-axis
setup and control functions16
Setup and Control Functions

Camera::Camera(CAM_TYPE ct) {




Camera::~Camera() {


void Camera::SetCameraType(CAM_TYPEct) {

CameraType = ct;


setup and control functions17
Setup and Control Functions

Vector3D Camera::GetPosition() {

return Position;


void Camera::Reset() {

Position = Vector3D(0.0, 0.0, 0.0);

Along = Vector3D(1.0, 0.0, 0.0);

Up = Vector3D(0.0, 1.0, 0.0);

Forward = Vector3D(0.0, 0.0, -1.0);



building the view matrix
Building the View Matrix
  • The last function called by Reset() is probably the most important
  • The Update() function applies all changes made to the viewing axes and camera position, and updates the view in MODELVIEW mode
  • In actual fact, as with gluLookAt(), the perception of camera motion is achieved by moving the objects around the scene while keeping the camera at a fixed position
  • Instead of using translations and rotations, a view matrix may be built, meaning that just one OpenGL function call is needed – glLoadMatrix()
building the view matrix19
Building the View Matrix
  • First we obtain the camera virtual position coordinates using the dot product of pairs of the view vectors:

void Camera::Update() {

GLfloat x = DotProduct(Along, Position);

GLfloat y = DotProduct(Up, Position);

GLfloat z = DotProduct(Forward, Position);


  • These will be used to translate the camera (or rather, the scene) to its correct position
building the view matrix20
Building the View Matrix
  • The translation part of the view matrix is shown below:

1 0 0 0

T = 0 1 0 0

0 0 1 0

–x –y z 1

  • Note that we must remember to make z positive, since for convenience we have taken “Forward” as meaning the direction into the screen which is opposite to OpenGL convention (Z-axis is positive outwards)
building the view matrix21
Building the View Matrix
  • The rotation part of the view matrix is built from the view vectors as shown:

A.x U.x –F.x

R = A.y U.y –F.y

A.z U.z –F.z

  • Again, the Forward vector is reversed
building the view matrix22
Building the View Matrix
  • Combining these two matrices, we get:

1 0 0 0 A.x U.x –F.x 0 A.x U.x –F.x 0

V = 0 1 0 0 . A.y U.y –F.y 0 = A.y U.y –F.y 0

0 0 1 0 A.z U.z –F.z 0 A.z U.z –F.z 0

–x –y z 1 0 0 0 1 –x –y z 1

  • The code on the following slides shows the rest of the implemented function
building the view matrix23
Building the View Matrix

void Camera::Update() {


Glfloat ViewMatrix[4][4];

ViewMatrix[0][0] = Along.x;

ViewMatrix[0][1] = Up.x;

ViewMatrix[0][2] = -Forward.x;

ViewMatrix[0][3] = 0.0;

ViewMatrix[1][0] = Along.y;

ViewMatrix[1][1] = Up.y;

ViewMatrix[1][2] = -Forward.y;

ViewMatrix[1][3] = 0.0;


building the view matrix24
Building the View Matrix


ViewMatrix[2][0] = Along.z;

ViewMatrix[2][1] = Up.z;

ViewMatrix[2][2] = -Forward.z;

ViewMatrix[2][3] = 0.0;

ViewMatrix[3][0] = -x;

ViewMatrix[3][1] = -y;

ViewMatrix[3][2] = z;

ViewMatrix[3][3] = 1.0;


glLoadMatrixf((GLfloat *)&ViewMatrix);


camera rotation functions
Camera Rotation Functions
  • The Pitch(), Yaw() and Roll() functions change the direction of the Forward, Along and Up vectors respectively
  • In each case, the rotation will result in the alteration of a second view vector, leaving one unchanged
  • The second modified vector is found by calculating the cross product of the other two vectors
  • This means that mutual orthognality is maintained for the three vectors
camera rotation functions26
Camera Rotation Functions
  • Looking at a yaw from above, we can see how to calculate the new direction of the Along vector:
camera rotation functions27
Camera Rotation Functions
  • Thus, for the Yaw function definition, we have:

void Camera::Yaw(GLfloat theta) {

Along = Along * cos(theta * DEG2RAD)

+ Forward * sin(theta * DEG2RAD);


Forward = CrossProduct(Along, Up) * -1.0;



  • Pitch() and Roll() on the following slide look very similar
camera rotation functions28
Camera Rotation Functions

void Camera::Pitch(GLfloat theta) {

// Invert UP/DOWN for air cameras

if(CameraType == AIR_CAM) theta = -theta;

Forward = Forward * cos(theta * DEG2RAD)

+ Up * sin(theta * DEG2RAD);


Up = CrossProduct(Forward, Along) * -1.0;



void Camera::Roll(GLfloat theta) {

if(CameraType == LAND_CAM) return; // Not for land cams

Up = Up * cos(theta * DEG2RAD)

- Along * sin(theta * DEG2RAD);


Along = CrossProduct(Forward, Up);



camera motion functions
Camera Motion Functions
  • Walk(), Strafe() and Fly() are a little easier to implement
  • In each case, all we have to do is add the correct scaled vector to the camera’s Position vector and update
  • As with rotation functions, motion functions work slightly differently depending on the type of camera being used
  • For example, when walking forward with a land camera, if the view has been pitched upwards, we do not want to move up the camera’s forward vector, but rather along a modified vector with the Y componet set to 0 – this will achieve the effect of staying on the ground rather than taking off into the air.
camera rotation functions30
Camera Rotation Functions
  • The Walk function with wall handling also implemented:

void Camera::Walk(GLfloat delta, bool Wall[4]) {

if(CameraType == LAND_CAM)

Position -= Vector3D(Forward.x *

!(Wall[0] && Forward.x * delta > 0.0 ||

Wall[1] && Forward.x * delta < 0.0),

0.0, Forward.z *

!(Wall[2] && Forward.z * delta > 0.0 ||

Wall[3] && Forward.z * delta < 0.0))

* delta;

else Position -= Forward * delta; // Air camera



camera rotation functions31
Camera Rotation Functions
  • Similarly, the Strafe function is defined as follows:

void Camera::Strafe(GLfloat delta, bool Wall[4]) {

if(CameraType == LAND_CAM)

Position -= Vector3D(Along.x *

!(Wall[0] && Along.x * delta > 0.0 ||

Wall[1] && Along.x * delta < 0.0),

0.0, Along.z *

!(Wall[2] && Along.z * delta > 0.0 ||

Wall[3] && Along.z * delta < 0.0))

* delta;

else Position += Along * delta; // Air camera



camera rotation functions32
Camera Rotation Functions
  • Finally, flying is, of course, only allowed for air cameras:

void Camera::Fly(GLfloat delta, bool Wall[4]) {

// Don't allow for land cameras

if(CameraType == LAND_CAM) return;

Position += Up * delta;



  • Although flying through walls has been allowed here, this would be implemented in the same manner as the previous two functions
  • Frank D. Luna, 2003, Introduction to 3D Game Programming with DirectX 9.0, Wordware Publishing, Inc.
  • Silicon Graphics Inc., 1997, OpenGL Programming Guide, Chapter 3 – Viewing, Addison-Wesley Publishing Company
  • Philipp Crocoll, The Advanced CodeColony Camera, http://www.codecolony.de/