libgdx API

com.badlogic.gdx.graphics
Class Camera

java.lang.Object
  extended by com.badlogic.gdx.graphics.Camera
Direct Known Subclasses:
OrthographicCamera, PerspectiveCamera

public abstract class Camera
extends java.lang.Object

Base class for OrthographicCamera and PerspectiveCamera.

Author:
mzechner

Field Summary
 Matrix4 combined
          the combined projection and view matrix
 Vector3 direction
          the unit length direction vector of the camera
 float far
          the far clipping plane distance, has to be positive
 Frustum frustum
          the frustum
 Matrix4 invProjectionView
          the inverse combined projection and view matrix
 float near
          the near clipping plane distance, has to be positive
 Vector3 position
          the position of the camera
 Matrix4 projection
          the projection matrix
 Vector3 up
          the unit length up vector of the camera
 Matrix4 view
          the view matrix
 float viewportHeight
          the viewport height
 float viewportWidth
          the viewport width
 
Constructor Summary
Camera()
           
 
Method Summary
 void apply(GL10 gl)
          Sets the current projection and model-view matrix of this camera.
 Ray getPickRay(float x, float y)
          Creates a picking Ray from the coordinates given in window coordinates.
 Ray getPickRay(float x, float y, float viewportX, float viewportY, float viewportWidth, float viewportHeight)
          Creates a picking Ray from the coordinates given in window coordinates.
 void lookAt(float x, float y, float z)
          Recalculates the direction of the camera to look at the point (x, y, z).
 void normalizeUp()
           
 void project(Vector3 vec)
          Projects the Vector3 given in object/world space to window coordinates.
 void project(Vector3 vec, float viewportX, float viewportY, float viewportWidth, float viewportHeight)
          Projects the Vector3 given in object/world space to window coordinates.
 void rotate(float angle, float axisX, float axisY, float axisZ)
          Rotates the direction and up vector of this camera by the given angle around the given axis.
 void translate(float x, float y, float z)
          Moves the camera by the given amount on each axis.
 void unproject(Vector3 vec)
          Function to translate a point given in window (or window) coordinates to world space.
 void unproject(Vector3 vec, float viewportX, float viewportY, float viewportWidth, float viewportHeight)
          Function to translate a point given in window (or window) coordinates to world space.
abstract  void update()
          Recalculates the projection and view matrix of this camera and the Frustum planes.
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

position

public final Vector3 position
the position of the camera


direction

public final Vector3 direction
the unit length direction vector of the camera


up

public final Vector3 up
the unit length up vector of the camera


projection

public final Matrix4 projection
the projection matrix


view

public final Matrix4 view
the view matrix


combined

public final Matrix4 combined
the combined projection and view matrix


invProjectionView

public final Matrix4 invProjectionView
the inverse combined projection and view matrix


near

public float near
the near clipping plane distance, has to be positive


far

public float far
the far clipping plane distance, has to be positive


viewportWidth

public float viewportWidth
the viewport width


viewportHeight

public float viewportHeight
the viewport height


frustum

public final Frustum frustum
the frustum

Constructor Detail

Camera

public Camera()
Method Detail

update

public abstract void update()
Recalculates the projection and view matrix of this camera and the Frustum planes. Use this after you've manipulated any of the attributes of the camera.


apply

public void apply(GL10 gl)
Sets the current projection and model-view matrix of this camera. Only works with GL10 and GL11 of course. The parameter is there to remind you that it does not work with GL20. Make sure to call update() before calling this method so all matrices are up to date.

Parameters:
gl - the GL10 or GL11 instance.

lookAt

public void lookAt(float x,
                   float y,
                   float z)
Recalculates the direction of the camera to look at the point (x, y, z).

Parameters:
x - the x-coordinate of the point to look at
y - the x-coordinate of the point to look at
z - the x-coordinate of the point to look at

normalizeUp

public void normalizeUp()

rotate

public void rotate(float angle,
                   float axisX,
                   float axisY,
                   float axisZ)
Rotates the direction and up vector of this camera by the given angle around the given axis. The direction and up vector will not be orthogonalized.

Parameters:
angle - the angle
axisX - the x-component of the axis
axisY - the y-component of the axis
axisZ - the z-component of the axis

translate

public void translate(float x,
                      float y,
                      float z)
Moves the camera by the given amount on each axis.

Parameters:
x - the displacement on the x-axis
y - the displacement on the y-axis
z - the displacement on the z-axis

unproject

public void unproject(Vector3 vec,
                      float viewportX,
                      float viewportY,
                      float viewportWidth,
                      float viewportHeight)
Function to translate a point given in window (or window) coordinates to world space. It's the same as GLU.gluUnProject(float, float, float, float[], int, float[], int, int[], int, float[], int) but does not rely on OpenGL. The x- and y-coordinate of vec are assumed to be in window coordinates (origin is the top left corner, y pointing down, x pointing to the right) as reported by the touch methods in Input. A z-coordinate of 0 will return a point on the near plane, a z-coordinate of 1 will return a point on the far plane. This method allows you to specify the viewport position and dimensions in the coordinate system expected by GLCommon.glViewport(int, int, int, int), with the origin in the bottom left corner of the screen.

Parameters:
vec - the point in window coordinates (origin top left)
viewportX - the coordinate of the top left corner of the viewport in glViewport coordinates (origin bottom left)
viewportY - the coordinate of the top left corner of the viewport in glViewport coordinates (origin bottom left)
viewportWidth - the width of the viewport in pixels
viewportHeight - the height of the viewport in pixels

unproject

public void unproject(Vector3 vec)
Function to translate a point given in window (or window) coordinates to world space. It's the same as GLU.gluUnProject(float, float, float, float[], int, float[], int, int[], int, float[], int) but does not rely on OpenGL. The viewport is assuemd to span the whole screen and is fetched from Graphics.getWidth() and Graphics.getHeight(). The x- and y-coordinate of vec are assumed to be in window coordinates (origin is the top left corner, y pointing down, x pointing to the right) as reported by the touch methods in Input. A z-coordinate of 0 will return a point on the near plane, a z-coordinate of 1 will return a point on the far plane.

Parameters:
vec - the point in window coordinates

project

public void project(Vector3 vec)
Projects the Vector3 given in object/world space to window coordinates. It's the same as GLU.gluProject(float, float, float, float[], int, float[], int, int[], int, float[], int) with one small deviation: The viewport is assumed to span the whole screen. The window coordinate system has its origin in the bottom left, with the y-axis pointing upwards and the x-axis pointing to the right. This makes it easily useable in conjunction with SpriteBatch and similar classes.

Parameters:
vec - the position in object/world space.

project

public void project(Vector3 vec,
                    float viewportX,
                    float viewportY,
                    float viewportWidth,
                    float viewportHeight)
Projects the Vector3 given in object/world space to window coordinates. It's the same as GLU.gluProject(float, float, float, float[], int, float[], int, int[], int, float[], int) with one small deviation: The viewport is assumed to span the whole screen. The window coordinate system has its origin in the bottom left, with the y-axis pointing upwards and the x-axis pointing to the right. This makes it easily useable in conjunction with SpriteBatch and similar classes. This method allows you to specify the viewport position and dimensions in the coordinate system expected by GLCommon.glViewport(int, int, int, int), with the origin in the bottom left corner of the screen.

Parameters:
vec - the point in object/world space
viewportX - the coordinate of the top left corner of the viewport in glViewport coordinates (origin bottom left)
viewportY - the coordinate of the top left corner of the viewport in glViewport coordinates (origin bottom left)
viewportWidth - the width of the viewport in pixels
viewportHeight - the height of the viewport in pixels

getPickRay

public Ray getPickRay(float x,
                      float y,
                      float viewportX,
                      float viewportY,
                      float viewportWidth,
                      float viewportHeight)
Creates a picking Ray from the coordinates given in window coordinates. It is assumed that the viewport spans the whole screen. The window coordinates origin is assumed to be in the top left corner, its y-axis pointing down, the x-axis pointing to the right. The returned instance is not a new instance but an internal member only accessible via this function.

Parameters:
x - the x-coordinate in window coordinates.
y - the y-coordinate in window coordinates.
Returns:
the picking Ray.

getPickRay

public Ray getPickRay(float x,
                      float y)
Creates a picking Ray from the coordinates given in window coordinates. It is assumed that the viewport spans the whole screen. The window coordinates origin is assumed to be in the top left corner, its y-axis pointing down, the x-axis pointing to the right. The returned instance is not a new instance but an internal member only accessible via this function.

Parameters:
x - the x-coordinate in window coordinates.
y - the y-coordinate in window coordinates.
Returns:
the picking Ray.

libgdx API

Copyright 2010 Mario Zechner (contact@badlogicgames.com), Nathan Sweet (admin@esotericsoftware.com)