#include <CUCamera.h>

Inheritance diagram for cugl::Camera:

Public Member Functions
	Camera ()

	~Camera ()

virtual void	dispose ()

const Vec3 &	getPosition () const

const Vec3 &	getDirection () const

const Vec3 &	getUp () const

float	getNear () const

void	setNear (float value)

float	getFar () const

void	setFar (float value)

const Rect &	getViewport () const

const Mat4 &	getProjection () const

const Mat4 &	getView () const

const Mat4 &	getCombined () const

const Mat4 &	getInverseProjectView () const

virtual void	update ()=0

void	lookAt (const Vec3 &target)

void	lookAt (float x, float y, float z)

void	normalizeUp ()

void	rotate (const Quaternion &quat)

void	rotate (const Vec3 &axis, float angle)

void	rotateX (float angle)

void	rotateY (float angle)

void	rotateZ (float angle)

void	rotate (float angle)

void	rotate (const Mat4 &transform)

void	rotateAround (const Vec3 &point, const Vec3 &axis, float angle)

void	translate (const Vec3 &vec)

void	translate (const Vec2 &vec)

void	translate (float tx, float ty, float tz)

void	translate (float tx, float ty)

void	transform (const Mat4 &transform)

Vec3	unproject (const Vec3 &windowCoords) const

Vec3	unproject (const Vec3 &windowCoords, const Rect &viewport) const

Vec3	screenToWorldCoords (const Vec2 &screenCoords) const

Vec3	project (const Vec3 &worldCoords) const

Vec3	project (const Vec3 &worldCoords, const Rect &viewport) const

Vec2	worldToScreenCoords (const Vec3 &worldCoords) const

Ray	getPickRay (const Vec3 &windowCoords) const

Ray	getPickRay (const Vec3 &windowCoords, const Rect &viewport) const

Ray	getPickRayFromScreen (const Vec2 &screenCoords) const

Vec2	windowToScreenCoords (const Vec3 &windowCoords) const

Vec2	windowToScreenCoords (const Vec3 &windowCoords, const Rect &viewport) const

Vec3	screenToWindowCoords (const Vec2 &screenCoords) const

Vec3	screenToWindowCoords (const Vec2 &screenCoords, const Rect &viewport) const

Protected Attributes
Vec3	_position

Vec3	_direction

Vec3	_upwards

Mat4	_projection

Mat4	_modelview

Mat4	_combined

Mat4	_inverse

float	_near

float	_far

Rect	_viewport

Detailed Description

This is a base class for a camera.

The actual cameras are OrthographicCamera and PerspectiveCamera. This class hash the shared functionality for transforms and queries in 3d space. In particular, it has several methods that help you to select a 3d object with the mouse.

Constructor & Destructor Documentation

cugl::Camera::Camera ( )

Creates a degenerate camera.

All of the matrices are the identity and the viewport is empty.

cugl::Camera::~Camera ( )

inline

Deletes this camera, disposing all resources.

Member Function Documentation

virtual void cugl::Camera::dispose ( )

virtual

Returns this camera to the denegerate one.

All of the matrices will be the identity and the viewport will be empty.

Reimplemented in cugl::PerspectiveCamera, and cugl::OrthographicCamera.

const Mat4& cugl::Camera::getCombined ( ) const

inline

Returns the combined projection and view matrix

Returns: the combined projection and view matrix

const Vec3& cugl::Camera::getDirection ( ) const

inline

Returns the unit length direction vector of the camera

Returns: the unit length direction vector of the camera

float cugl::Camera::getFar ( ) const

inline

Returns the far clipping plane distance (has to be positive)

Returns: the far clipping plane distance (has to be positive)

const Mat4& cugl::Camera::getInverseProjectView ( ) const

inline

Returns the combined projection and view matrix

Returns: the combined projection and view matrix

float cugl::Camera::getNear ( ) const

inline

Returns the near clipping plane distance (has to be positive)

Returns: the near clipping plane distance (has to be positive)

Ray cugl::Camera::getPickRay ( const Vec3 & windowCoords ) const

Returns a picking Ray from the coordinates given in window coordinates.

A picking ray is used to select an object in 3d space. It creates a ray into the screen based on a selection in the viewport. You can then use this ray to select an object.

Window coords are the location of the point in the viewport. Ideally, the viewport should be the same size as the screen, but these are not screen coordinates. The screen has the origin in the top left, while window coordinates still have the origin in the bottom left.

While the viewport is a flat 2d plane, this method still takes a 3d point. The z-coordinate corresponds to the position of the point in the z-buffer.

Parameters

windowCoords The point in window coordinates

Returns a picking Ray from the coordinates given in window coordinates.

Ray cugl::Camera::getPickRay	(	const Vec3 &	windowCoords,
		const Rect &	viewport
	)		const

Returns a picking Ray from the coordinates given in window coordinates.

A picking ray is used to select an object in 3d space. It creates a ray into the screen based on a selection in the viewport. You can then use this ray to select an object.

Window coords are the location of the point in the viewport. Ideally, the viewport should be the same size as the screen, but these are not screen coordinates. The screen has the origin in the top left, while window coordinates still have the origin in the bottom left.

While the viewport is a flat 2d plane, this method still takes a 3d point. The z-coordinate corresponds to the position of the point in the z-buffer.

Parameters

windowCoords	The point in window coordinates
viewport	The screen viewport

Returns a picking Ray from the coordinates given in window coordinates.

Ray cugl::Camera::getPickRayFromScreen ( const Vec2 & screenCoords ) const

inline

Returns a picking Ray from the coordinates given in screen coordinates.

A picking ray is used to select an object in 3d space. It creates a ray into the screen based on a selection in the viewport. You can then use this ray to select an object.

Screen coords differ from window coordinates, as the the origin is in the top left instad of the bottom left. The SDL event system uses screen space for input events, which is why this method is necessary.

Parameters

screenCoords The point in screen coordinates

Returns a picking Ray from the coordinates given in screen coordinates.

const Vec3& cugl::Camera::getPosition ( ) const

inline

Returns the position of the camera

Returns: the position of the camera

const Mat4& cugl::Camera::getProjection ( ) const

inline

Returns the projection matrix

Returns: the projection matrix

const Vec3& cugl::Camera::getUp ( ) const

inline

Returns the unit length up vector of the camera

Returns: the unit length up vector of the camera

const Mat4& cugl::Camera::getView ( ) const

inline

Returns the view matrix

Returns: the view matrix

const Rect& cugl::Camera::getViewport ( ) const

inline

Returns the viewport

The viewport represents the "screen space". However, it is not actually screen space because the origin is still in the bottom left corner. So we call ir Window space instead.

Returns: the viewport size

void cugl::Camera::lookAt ( const Vec3 & target )

Sets the direction of the camera to look at the given point.

This function assumes the up vector is normalized.

Parameters

target The point to look at

void cugl::Camera::lookAt	(	float	x,
		float	y,
		float	z
	)

inline

Sets the direction of the camera to look at the given point.

This function assumes the up vector is normalized.

Parameters

x	The x-coordinate of the point to look at
y	The y-coordinate of the point to look at
z	The z-coordinate of the point to look at

void cugl::Camera::normalizeUp ( )

inline

Normalizes the up vector to be orthogonal to direction.

This method first calculats the right vector via a cross product between direction and up. Then it recalculates the up vector via a cross product between right and direction.

Vec3 cugl::Camera::project ( const Vec3 & worldCoords ) const

Returns the window space equivalent of a point in world coordinates.

This is the same as GLU gluProject. Window coords are the location of the point in the viewport. Ideally, the viewport should be the same size as the screen, but these are not screen coordinates. The screen has the origin in the top left, while

While the viewport is a flat 2d plane, this method still returns a 3d point. The z-coordinate corresponds to the position of the point in the z-buffer.

Parameters

worldCoords The point in wprld coordinates

Returns: the window space equivalent of a point in world coordinates.

Vec3 cugl::Camera::project	(	const Vec3 &	worldCoords,
		const Rect &	viewport
	)		const

Returns the window space equivalent of a point in world coordinates.

This is the same as GLU gluProject. Window coords are the location of the point in the viewport. Ideally, the viewport should be the same size as the screen, but these are not screen coordinates. The screen has the origin in the top left, while

While the viewport is a flat 2d plane, this method still returns a 3d point. The z-coordinate corresponds to the position of the point in the z-buffer.

Parameters

worldCoords	The point in world coordinates
viewport	The screen viewport

Returns: the window space equivalent of a point in world coordinates.

void cugl::Camera::rotate ( const Quaternion & quat )

inline

Rotates the direction and up vector by the given Quaternion

You must call update() for the view matrix to be updated. The direction and up vector will not be orthogonalized until you call update().

Parameters

quat	The rotation quaternion.

void cugl::Camera::rotate	(	const Vec3 &	axis,
		float	angle
	)

inline

Rotates the direction and up vector by the given angle around the given axis.

You must call update() for the view matrix to be updated. The direction and up vector will not be orthogonalized until you call update().

Parameters

axis	The axis to rotate about.
angle	The angle (in radians).

void cugl::Camera::rotate ( float angle )

inline

Rotates the camera by the given angle around the direction vector.

You must call update() for the view matrix to be updated. The direction and up vector will not be orthogonalized until you call update().

Parameters

angle The angle (in radians).

void cugl::Camera::rotate ( const Mat4 & transform )

inline

Rotates the direction and up vector of this camera by the given matrix.

You must call update() for the view matrix to be updated. The direction and up vector will not be orthogonalized until you call update().

The translational and scaling components of the matrix will be ignored.

Parameters

transform The rotation matrix

void cugl::Camera::rotateAround	(	const Vec3 &	point,
		const Vec3 &	axis,
		float	angle
	)

Rotates the direction and up vector by the given angle around the given axis.

This version of the method assumes the axis is attached to the given point.

You must call update() for the view matrix to be updated. The direction and up vector will not be orthogonalized until you call update().

Parameters

point	The point to attach the axis to
axis	The axis to rotate about.
angle	The angle (in radians).

void cugl::Camera::rotateX ( float angle )

inline

Rotates the direction and up vectod by the given angle around the x-axis.

You must call update() for the view matrix to be updated. The direction and up vector will not be orthogonalized until you call update().

Parameters

angle The angle (in radians).

void cugl::Camera::rotateY ( float angle )

inline

Rotates the direction and up vectod by the given angle around the z-axis.

You must call update() for the view matrix to be updated. The direction and up vector will not be orthogonalized until you call update().

Parameters

angle The angle (in radians).

void cugl::Camera::rotateZ ( float angle )

inline

Rotates the direction and up vectod by the given angle around the z-axis.

You must call update() for the view matrix to be updated. The direction and up vector will not be orthogonalized until you call update().

Parameters

angle The angle (in radians).

Vec3 cugl::Camera::screenToWindowCoords ( const Vec2 & screenCoords ) const

Returns the screen space equivalent of a point in window coordinates.

Ideally, window space and screen space would be the same space. They are both defined by the viewport and have the same offset and dimension. However, screen coordinates have the origin in the top left while window coordinates have the origin in the bottom left.

We need this conversion because events (such as mouse clicks) register in screen space, while drawing happens in window space.

While the viewport is a flat 2d plane, this method still takes a 3d point. The z-coordinate corresponds to the near position, closest to the screen.

Parameters

screenCoords The point in screen coordinates

Vec3 cugl::Camera::screenToWindowCoords	(	const Vec2 &	screenCoords,
		const Rect &	viewport
	)		const

Returns the screen space equivalent of a point in window coordinates.

Ideally, window space and screen space would be the same space. They are both defined by the viewport and have the same offset and dimension. However, screen coordinates have the origin in the top left while window coordinates have the origin in the bottom left.

We need this conversion because events (such as mouse clicks) register in screen space, while drawing happens in window space.

While the viewport is a flat 2d plane, this method still takes a 3d point. The z-coordinate corresponds to the near position, closest to the screen.

Parameters

screenCoords	The point in screen coordinates
viewport	The screen viewport

Vec3 cugl::Camera::screenToWorldCoords ( const Vec2 & screenCoords ) const

inline

Returns the world space equivalent of a point in screen coordinates.

Ideally, window space and screen space would be the same space. They are both defined by the viewport and have the same offset and dimension. However, screen coordinates have the origin in the top left while window coordinates have the origin in the bottom left.

In computing the world space coordinates, this method assumes that the z-value of the original vector is the same as near, which is the closest it can be the screen.

This method is important for converting event coordinates (such as a mouse click) to world coordinates.

Parameters

screenCoords The point in screen coordinates

Returns: the world space equivalent of a point in screen coordinates.

void cugl::Camera::setFar ( float value )

inline

Sets the far clipping plane distance (has to be positive)

Changing this value will have no effect on the underlying matrices until you call the update() method.

Parameters

value The far clipping plane distance (has to be positive)

void cugl::Camera::setNear ( float value )

inline

Sets the near clipping plane distance (has to be positive)

Changing this value will have no effect on the underlying matrices until you call the update() method.

Parameters

value The near clipping plane distance (has to be positive)

void cugl::Camera::transform ( const Mat4 & transform )

inline

Transforms the position, direction and up vector by the given matrix

You must call update() for the view matrix to be updated. The direction and up vector will not be orthogonalized until you call update().

Parameters

transform The transform matrix

void cugl::Camera::translate ( const Vec3 & vec )

inline

Moves the camera by the given vector.

Parameters

vec	The displacement vector

void cugl::Camera::translate ( const Vec2 & vec )

inline

Moves the camera by the given vector.

You must call update() for the view matrix to be updated. The direction and up vector will not be orthogonalized until you call update().

Parameters

vec	The displacement vector

void cugl::Camera::translate	(	float	tx,
		float	ty,
		float	tz
	)

inline

Moves the camera by the given vector.

You must call update() for the view matrix to be updated. The direction and up vector will not be orthogonalized until you call update().

Parameters

tx	The displacement on the x-axis
ty	The displacement on the y-axis
tz	The displacement on the z-axis

void cugl::Camera::translate	(	float	tx,
		float	ty
	)

inline

Moves the camera by the given vector.

You must call update() for the view matrix to be updated. The direction and up vector will not be orthogonalized until you call update().

Parameters

tx	The displacement on the x-axis
ty	The displacement on the y-axis

Vec3 cugl::Camera::unproject ( const Vec3 & windowCoords ) const

Returns the world space equivalent of a point in window coordinates.

This is the same as GLU gluUnProject, but does not rely on OpenGL. Window coords are the location of the point in the viewport. Ideally, the viewport should be the same size as the screen, but these are not screen coordinates. The screen has the origin in the top left, while Window coordinates still have the origin in the bottom left.

While the viewport is a flat 2d plane, this method still requires a 3d point. The z-coordinate corresponds to the position of the point in the z-buffer.

Parameters

windowCoords The point in window coordinates

Returns: the world space equivalent of a point in window coordinates.

Vec3 cugl::Camera::unproject	(	const Vec3 &	windowCoords,
		const Rect &	viewport
	)		const

Returns the world space equivalent of a point in window coordinates.

This is the same as GLU gluUnProject, but does not rely on OpenGL. Window coords are the location of the point in the viewport. Ideally, the viewport should be the same size as the screen, but these are not screen coordinates. The screen has the origin in the top left, while Window coordinates still have the origin in the bottom left.

While the viewport is a flat 2d plane, this method still requires a 3d point. The z-coordinate corresponds to the position of the point in the z-buffer.

Parameters

windowCoords	The point in window coordinates
viewport	The screen viewport

Returns: the world space equivalent of a point in window coordinates.

virtual void cugl::Camera::update ( )

pure virtual

Recalculates the projection and view matrix of this camera.

Use this after you've manipulated any of the attributes of the camera.

Implemented in cugl::PerspectiveCamera, and cugl::OrthographicCamera.

Vec2 cugl::Camera::windowToScreenCoords ( const Vec3 & windowCoords ) const

Returns the window space equivalent of a point in screen coordinates.

Ideally, window space and screen space would be the same space. They are both defined by the viewport and have the same offset and dimension. However, screen coordinates have the origin in the top left while window coordinates have the origin in the bottom left.

We need this conversion because events (such as mouse clicks) register in screen space, while drawing happens in window space.

Parameters

windowCoords The point in window coordinates

Vec2 cugl::Camera::windowToScreenCoords	(	const Vec3 &	windowCoords,
		const Rect &	viewport
	)		const

Returns the window space equivalent of a point in screen coordinates.

Ideally, window space and screen space would be the same space. They are both defined by the viewport and have the same offset and dimension. However, screen coordinates have the origin in the top left while window coordinates have the origin in the bottom left.

We need this conversion because events (such as mouse clicks) register in screen space, while drawing happens in window space.

Parameters

windowCoords	The point in window coordinates
viewport	The screen viewport

Vec2 cugl::Camera::worldToScreenCoords ( const Vec3 & worldCoords ) const

inline

Returns the screen space equivalent of a point in world coordinates.

Ideally, window space and screen space would be the same space. They are both defined by the viewport and have the same offset and dimension. However, screen coordinates have the origin in the top left while window coordinates have the origin in the bottom left.

This method is important for converting world coordinates to event coordinates (such as a mouse click).

Parameters

worldCoords The point in wprld coordinates

Returns: the screen space equivalent of a point in world coordinates.

Member Data Documentation

Mat4 cugl::Camera::_combined

protected

The combined projection and view matrix

Vec3 cugl::Camera::_direction

protected

The unit length direction vector of the camera

float cugl::Camera::_far

protected

The far clipping plane distance, has to be positive

Mat4 cugl::Camera::_inverse

protected

The inverse of the combined projection and view matrix

Mat4 cugl::Camera::_modelview

protected

The view matrix

float cugl::Camera::_near

protected

The near clipping plane distance, has to be positive

Vec3 cugl::Camera::_position

protected

The position of the camera

Mat4 cugl::Camera::_projection

protected

The projection matrix

Vec3 cugl::Camera::_upwards

protected

The unit length up vector of the camera

Rect cugl::Camera::_viewport

protected

The Window viewport

The documentation for this class was generated from the following file:

renderer/CUCamera.h

Public Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation