csCamera

In file include/csengine/camera.h:

class csCamera : public csOrthoTransform

A camera positioned in the 3D world

Inheritance:

Public Fields
static int aspect
static float inv_aspect

Public Methods
inline csVector3 Camera2World(const csVector3& v): Transform a camera space point to world space
inline csVector3 Camera2WorldRelative(const csVector3& v): Transform a camera space point to worldspace, relative to camera position
void Correct(int n): Eliminate roundoff error by snapping the camera orientation to a grid of density n
csCamera()
inline csMatrix3 GetC2W(): Return the camera to world transformation matrix
static int GetFOV(): Get the FOV for this camera
csPolygon3D* GetHit(csVector3& v): Check if there is a polygon in front of us in the direction defined by 'v' (world space coordinates)
csSector* GetSector(): Get the current sector of the camera
inline csMatrix3 GetW2C(): Return the world to camera transformation matrix
inline csVector3 GetW2CTranslation(): Return the world to camera translation
bool IsMirrored(): Returns true if we are in a mirrored world
bool LoadFile(csWorld* world, char* filename): Load the camera position from a file as saved by SaveFile()
void LookAt(const csVector3& v, const csVector3& up): Have the camera look at the given (x,y,z) point, using up as the up-vector
void Move(const csVector3& v): Moves the camera a relative amount in camera coordinates
void MoveUnrestricted(const csVector3& v): Moves the camera a relative amount in camera coordinates, ignoring portals and walls
void MoveWorld(const csVector3& v): Moves the camera a relative amount in world coordinates
void MoveWorldUnrestricted(const csVector3& v): Moves the camera a relative amount in world coordinates, ignoring portals and walls
void Rotate(const csMatrix3& m): Use the given transformation matrix, in camera space, to reorient the camera
void Rotate(const csVector3& v, float angle): Rotate the camera by the angle (radians) around the given vector, in camera coordinates
void RotateWorld(const csVector3& v, float angle): Rotate the camera by the angle (radians) around the given vector, in world coordinates
void RotateWorld(const csMatrix3& m): Use the given transformation matrix, in worldspace, to reorient the camera
void SaveFile(char* filename): Save the camera position to a file
inline void SetC2W(const csMatrix3& m): Set the camera to world transformation matrix
static void SetFOV(int fov): Set the FOV to use for this camera
void SetMirrored(bool m): Set the mirrored state of this camera
inline void SetPosition(const csVector3& v): Sets the absolute position of the camera inside the sector
void SetSector(csSector *s): Set the sector that the camera resides in
inline void SetW2C(const csMatrix3& m): Set the world to camera transformation matrix
inline csVector3 World2Camera(const csVector3& v): Transform a worldspace point to camera space
virtual ~csCamera()

Private Fields
bool mirror: If true we are in a mirrored world.
csSector* sector: The sector the camera is in.

Private Methods
void Correct(int n, float* vals[])

Inherited from csOrthoTransform:

Public Methods
virtual void SetO2T(const csMatrix3& m)
virtual void SetT2O(const csMatrix3& m)

Inherited from csReversibleTransform:

Public Methods
csReversibleTransform GetInverse()
inline const csMatrix3& GetT2O()
inline csVector3 GetT2OTranslation()
friend csReversibleTransform operator* (const csReversibleTransform& t1, const csReversibleTransform& t2)
friend csTransform operator* (const csTransform& t1, const csReversibleTransform& t2)
friend csReversibleTransform& operator*= (csReversibleTransform& t1, const csReversibleTransform& t2)
friend csPlane operator/ (const csPlane& p, const csReversibleTransform& t)
friend csVector3 operator/ (const csVector3& v, const csReversibleTransform& t)
friend csReversibleTransform operator/ (const csReversibleTransform& t1, const csReversibleTransform& t2)
friend csVector3& operator/= (csVector3& v, const csReversibleTransform& t)
friend csReversibleTransform& operator/= (csReversibleTransform& t1, const csReversibleTransform& t2)
friend csPlane& operator/= (csPlane& p, const csReversibleTransform& t)
csPlane This2Other(const csPlane& p)
void This2Other(const csPlane& p, const csVector3& point, csPlane& result)
csVector3 This2Other(const csVector3& v)
inline csVector3 This2OtherRelative(const csVector3& v)

Protected Fields
csMatrix3 m_t2o

Inherited from csTransform:

Public Methods
inline const csMatrix3& GetO2T()
inline const csVector3& GetO2TTranslation()
inline const csVector3& GetOrigin()
static csTransform GetReflect(const csPlane& pl)
csPlane Other2This(const csPlane& p)
inline csVector3 Other2This(const csVector3& v)
void Other2This(const csPlane& p, const csVector3& point, csPlane& result)
csVector3 Other2ThisRelative(const csVector3& v)
inline void SetO2TTranslation(const csVector3& v)
inline void SetOrigin(const csVector3& v)
inline void Translate(const csVector3& v)

Protected Fields
csMatrix3 m_o2t
csVector3 v_o2t

Documentation

A camera positioned in the 3D world

csSector* sector

The sector the camera is in.

bool mirror

If true we are in a mirrored world.

static int aspect

static float inv_aspect

csCamera()

virtual ~csCamera()

void SaveFile(char* filename)

Save the camera position to a file. The camera can then later be restored by using LoadFile(). This function is mainly useful for debugging.

bool LoadFile(csWorld* world, char* filename)

Load the camera position from a file as saved by SaveFile(). This function is mainly useful for debugging.

csPolygon3D* GetHit(csVector3& v)

Check if there is a polygon in front of us in the direction defined by 'v' (world space coordinates). Return the nearest polygon.

static void SetFOV(int fov)

Set the FOV to use for this camera

static int GetFOV()

Get the FOV for this camera

void SetSector(csSector *s)

Set the sector that the camera resides in. Note that this function does not check if the current camera location is really in that sector. In fact it is legal to have a camera which is viewing the current sector from outside.

csSector* GetSector()

Get the current sector of the camera

bool IsMirrored()

Returns true if we are in a mirrored world. Basicly this means that back-face culling will be reversed.

void SetMirrored(bool m)

Set the mirrored state of this camera. The effect of this is mainly that back-face culling will be reversed. This is useful if you are stepping into a mirrored sector.

inline void SetPosition(const csVector3& v)

Sets the absolute position of the camera inside the sector. Vector 'v' is in world space coordinates. This function does not check if the vector is really in the current sector. In fact it is legal to set the position outside the sector boundaries.

inline void SetW2C(const csMatrix3& m)

Set the world to camera transformation matrix. This basicly defines the direction that the camera looks.

inline void SetC2W(const csMatrix3& m)

Set the camera to world transformation matrix. This basicly defines the direction that the camera looks.

inline csMatrix3 GetW2C()

Return the world to camera transformation matrix

inline csMatrix3 GetC2W()

Return the camera to world transformation matrix

inline csVector3 GetW2CTranslation()

Return the world to camera translation

inline csVector3 World2Camera(const csVector3& v)

Transform a worldspace point to camera space

inline csVector3 Camera2World(const csVector3& v)

Transform a camera space point to world space

inline csVector3 Camera2WorldRelative(const csVector3& v)

Transform a camera space point to worldspace, relative to camera position

void MoveWorld(const csVector3& v)

Moves the camera a relative amount in world coordinates

void Move(const csVector3& v)

Moves the camera a relative amount in camera coordinates

void MoveWorldUnrestricted(const csVector3& v)

Moves the camera a relative amount in world coordinates, ignoring portals and walls. This is used by the wireframe class. In general this is useful by any camera model that doesn't want to restrict its movement by portals and sector boundaries.

void MoveUnrestricted(const csVector3& v)

Moves the camera a relative amount in camera coordinates, ignoring portals and walls. This is used by the wireframe class. In general this is useful by any camera model that doesn't want to restrict its movement by portals and sector boundaries.

void RotateWorld(const csVector3& v, float angle)

Rotate the camera by the angle (radians) around the given vector, in world coordinates. Note: this function rotates the camera, not the coordinate system.

void Rotate(const csVector3& v, float angle)

Rotate the camera by the angle (radians) around the given vector, in camera coordinates. Note: this function rotates the camera, not the coordinate system.

void RotateWorld(const csMatrix3& m)