irr::scene::SViewFrustum Struct Reference

Defines the view frustum. That's the space visible by the camera. More...

#include <SViewFrustum.h>

Public Types
enum	VFPLANES {   VF_FAR_PLANE = 0, VF_NEAR_PLANE, VF_LEFT_PLANE, VF_RIGHT_PLANE,   VF_BOTTOM_PLANE, VF_TOP_PLANE, VF_PLANE_COUNT }

Public Member Functions
	SViewFrustum ()
	Default Constructor. More...
	SViewFrustum (const SViewFrustum &other)
	Copy Constructor. More...
	SViewFrustum (const core::matrix4 &mat, bool zClipFromZero)
	This constructor creates a view frustum based on a projection and/or view matrix. More...
void	setFrom (const core::matrix4 &mat, bool zClipFromZero)
	This constructor creates a view frustum based on a projection and/or view matrix. More...
void	transform (const core::matrix4 &mat)
	transforms the frustum by the matrix More...
core::vector3df	getFarLeftUp () const
	returns the point which is on the far left upper corner inside the the view frustum. More...
core::vector3df	getFarLeftDown () const
	returns the point which is on the far left bottom corner inside the the view frustum. More...
core::vector3df	getFarRightUp () const
	returns the point which is on the far right top corner inside the the view frustum. More...
core::vector3df	getFarRightDown () const
	returns the point which is on the far right bottom corner inside the the view frustum. More...
core::vector3df	getNearLeftUp () const
	returns the point which is on the near left upper corner inside the the view frustum. More...
core::vector3df	getNearLeftDown () const
	returns the point which is on the near left bottom corner inside the the view frustum. More...
core::vector3df	getNearRightUp () const
	returns the point which is on the near right top corner inside the the view frustum. More...
core::vector3df	getNearRightDown () const
	returns the point which is on the near right bottom corner inside the the view frustum. More...
const core::aabbox3d< f32 > &	getBoundingBox () const
	returns a bounding box enclosing the whole view frustum More...
void	recalculateBoundingBox ()
	recalculates the bounding box and sphere based on the planes More...
float	getBoundingRadius () const
	get the bounding sphere's radius (of an optimized sphere, not the AABB's) More...
core::vector3df	getBoundingCenter () const
	get the bounding sphere's radius (of an optimized sphere, not the AABB's) More...
void	setFarNearDistance (float distance)
	the cam should tell the frustum the distance between far and near More...
core::matrix4 &	getTransform (video::E_TRANSFORMATION_STATE state)
	get the given state's matrix based on frustum E_TRANSFORMATION_STATE More...
const core::matrix4 &	getTransform (video::E_TRANSFORMATION_STATE state) const
	get the given state's matrix based on frustum E_TRANSFORMATION_STATE More...
bool	clipLine (core::line3d< f32 > &line) const
	clips a line to the view frustum. More...

Public Attributes
core::vector3df	cameraPosition
	the position of the camera More...
core::plane3d< f32 >	planes [VF_PLANE_COUNT]
	all planes enclosing the view frustum. More...
core::aabbox3d< f32 >	boundingBox
	bounding box around the view frustum More...

Detailed Description

Defines the view frustum. That's the space visible by the camera.

The view frustum is enclosed by 6 planes. These six planes share eight points. A bounding box around these eight points is also stored in this structure.

Definition at line 25 of file SViewFrustum.h.

Member Enumeration Documentation

VFPLANES

enum irr::scene::SViewFrustum::VFPLANES

Enumerator
VF_FAR_PLANE	Far plane of the frustum. That is the plane furthest away from the eye.
VF_NEAR_PLANE	Near plane of the frustum. That is the plane nearest to the eye.
VF_LEFT_PLANE	Left plane of the frustum.
VF_RIGHT_PLANE	Right plane of the frustum.
VF_BOTTOM_PLANE	Bottom plane of the frustum.
VF_TOP_PLANE	Top plane of the frustum.
VF_PLANE_COUNT	Amount of planes enclosing the view frustum. Should be 6.

Definition at line 27 of file SViewFrustum.h.

                {
                        VF_FAR_PLANE = 0,
                        VF_NEAR_PLANE,
                        VF_LEFT_PLANE,
                        VF_RIGHT_PLANE,
                        VF_BOTTOM_PLANE,
                        VF_TOP_PLANE,

                        VF_PLANE_COUNT
                };

Constructor & Destructor Documentation

SViewFrustum() [1/3]

irr::scene::SViewFrustum::SViewFrustum ( )

inline

Default Constructor.

Definition at line 48 of file SViewFrustum.h.

: BoundingRadius(0.f), FarNearDistance(0.f) {}

SViewFrustum() [2/3]

irr::scene::SViewFrustum::SViewFrustum ( const SViewFrustum &  other )

inline

Copy Constructor.

Copy constructor ViewFrustum

Definition at line 147 of file SViewFrustum.h.

        {
                cameraPosition=other.cameraPosition;
                boundingBox=other.boundingBox;

                u32 i;
                for (i=0; i<VF_PLANE_COUNT; ++i)
                        planes[i]=other.planes[i];

                for (i=0; i<ETS_COUNT_FRUSTUM; ++i)
                        Matrices[i]=other.Matrices[i];

                BoundingRadius = other.BoundingRadius;
                FarNearDistance = other.FarNearDistance;
                BoundingCenter = other.BoundingCenter;
        }

SViewFrustum() [3/3]

irr::scene::SViewFrustum::SViewFrustum ( const core::matrix4 &  mat, bool  zClipFromZero  )

inline

This constructor creates a view frustum based on a projection and/or view matrix.

Definition at line 164 of file SViewFrustum.h.

        {
                setFrom(mat, zClipFromZero);
        }

Member Function Documentation

clipLine()

bool irr::scene::SViewFrustum::clipLine ( core::line3d< f32 > &  line ) const

inline

clips a line to the view frustum.

Clips a line to the frustum.

Returns

True if the line was clipped, false if not

Definition at line 397 of file SViewFrustum.h.

        {
                bool wasClipped = false;
                for (u32 i=0; i < VF_PLANE_COUNT; ++i)
                {
                        if (planes[i].classifyPointRelation(line.start) == core::ISREL3D_FRONT)
                        {
                                line.start = line.start.getInterpolated(line.end,
                                                1.f-planes[i].getKnownIntersectionWithLine(line.start, line.end));
                                wasClipped = true;
                        }
                        if (planes[i].classifyPointRelation(line.end) == core::ISREL3D_FRONT)
                        {
                                line.end = line.start.getInterpolated(line.end,
                                                1.f-planes[i].getKnownIntersectionWithLine(line.start, line.end));
                                wasClipped = true;
                        }
                }
                return wasClipped;
        }

getBoundingBox()

const core::aabbox3d< f32 > & irr::scene::SViewFrustum::getBoundingBox ( ) const

inline

returns a bounding box enclosing the whole view frustum

Definition at line 260 of file SViewFrustum.h.

        {
                return boundingBox;
        }

getBoundingCenter()

core::vector3df irr::scene::SViewFrustum::getBoundingCenter ( ) const

inline

get the bounding sphere's radius (of an optimized sphere, not the AABB's)

Definition at line 285 of file SViewFrustum.h.

        {
                return BoundingCenter;
        }

getBoundingRadius()

float irr::scene::SViewFrustum::getBoundingRadius ( ) const

inline

get the bounding sphere's radius (of an optimized sphere, not the AABB's)

Definition at line 280 of file SViewFrustum.h.

        {
                return BoundingRadius;
        }

getFarLeftDown()

core::vector3df irr::scene::SViewFrustum::getFarLeftDown ( ) const

inline

returns the point which is on the far left bottom corner inside the the view frustum.

Definition at line 190 of file SViewFrustum.h.

        {
                core::vector3df p;
                planes[scene::SViewFrustum::VF_FAR_PLANE].getIntersectionWithPlanes(
                        planes[scene::SViewFrustum::VF_BOTTOM_PLANE],
                        planes[scene::SViewFrustum::VF_LEFT_PLANE], p);

                return p;
        }

getFarLeftUp()

core::vector3df irr::scene::SViewFrustum::getFarLeftUp ( ) const

inline

returns the point which is on the far left upper corner inside the the view frustum.

Definition at line 180 of file SViewFrustum.h.

        {
                core::vector3df p;
                planes[scene::SViewFrustum::VF_FAR_PLANE].getIntersectionWithPlanes(
                        planes[scene::SViewFrustum::VF_TOP_PLANE],
                        planes[scene::SViewFrustum::VF_LEFT_PLANE], p);

                return p;
        }

getFarRightDown()

core::vector3df irr::scene::SViewFrustum::getFarRightDown ( ) const

inline

returns the point which is on the far right bottom corner inside the the view frustum.

Definition at line 210 of file SViewFrustum.h.

        {
                core::vector3df p;
                planes[scene::SViewFrustum::VF_FAR_PLANE].getIntersectionWithPlanes(
                        planes[scene::SViewFrustum::VF_BOTTOM_PLANE],
                        planes[scene::SViewFrustum::VF_RIGHT_PLANE], p);

                return p;
        }

getFarRightUp()

core::vector3df irr::scene::SViewFrustum::getFarRightUp ( ) const

inline

returns the point which is on the far right top corner inside the the view frustum.

Definition at line 200 of file SViewFrustum.h.

        {
                core::vector3df p;
                planes[scene::SViewFrustum::VF_FAR_PLANE].getIntersectionWithPlanes(
                        planes[scene::SViewFrustum::VF_TOP_PLANE],
                        planes[scene::SViewFrustum::VF_RIGHT_PLANE], p);

                return p;
        }

getNearLeftDown()

core::vector3df irr::scene::SViewFrustum::getNearLeftDown ( ) const

inline

returns the point which is on the near left bottom corner inside the the view frustum.

Definition at line 230 of file SViewFrustum.h.

        {
                core::vector3df p;
                planes[scene::SViewFrustum::VF_NEAR_PLANE].getIntersectionWithPlanes(
                        planes[scene::SViewFrustum::VF_BOTTOM_PLANE],
                        planes[scene::SViewFrustum::VF_LEFT_PLANE], p);

                return p;
        }

getNearLeftUp()

core::vector3df irr::scene::SViewFrustum::getNearLeftUp ( ) const

inline

returns the point which is on the near left upper corner inside the the view frustum.

Definition at line 220 of file SViewFrustum.h.

        {
                core::vector3df p;
                planes[scene::SViewFrustum::VF_NEAR_PLANE].getIntersectionWithPlanes(
                        planes[scene::SViewFrustum::VF_TOP_PLANE],
                        planes[scene::SViewFrustum::VF_LEFT_PLANE], p);

                return p;
        }

getNearRightDown()

core::vector3df irr::scene::SViewFrustum::getNearRightDown ( ) const

inline

returns the point which is on the near right bottom corner inside the the view frustum.

Definition at line 250 of file SViewFrustum.h.

        {
                core::vector3df p;
                planes[scene::SViewFrustum::VF_NEAR_PLANE].getIntersectionWithPlanes(
                        planes[scene::SViewFrustum::VF_BOTTOM_PLANE],
                        planes[scene::SViewFrustum::VF_RIGHT_PLANE], p);

                return p;
        }

getNearRightUp()

core::vector3df irr::scene::SViewFrustum::getNearRightUp ( ) const

inline

returns the point which is on the near right top corner inside the the view frustum.

Definition at line 240 of file SViewFrustum.h.

        {
                core::vector3df p;
                planes[scene::SViewFrustum::VF_NEAR_PLANE].getIntersectionWithPlanes(
                        planes[scene::SViewFrustum::VF_TOP_PLANE],
                        planes[scene::SViewFrustum::VF_RIGHT_PLANE], p);

                return p;
        }

getTransform() [1/2]

core::matrix4 & irr::scene::SViewFrustum::getTransform ( video::E_TRANSFORMATION_STATE  state )

inline

get the given state's matrix based on frustum E_TRANSFORMATION_STATE

View Frustum depends on Projection & View Matrix

Definition at line 363 of file SViewFrustum.h.

        {
                u32 index = 0;
                switch ( state )
                {
                        case video::ETS_PROJECTION:
                                index = SViewFrustum::ETS_PROJECTION; break;
                        case video::ETS_VIEW:
                                index = SViewFrustum::ETS_VIEW; break;
                        default:
                                break;
                }
                return Matrices [ index ];
        }

getTransform() [2/2]

const core::matrix4 & irr::scene::SViewFrustum::getTransform ( video::E_TRANSFORMATION_STATE  state ) const

inline

get the given state's matrix based on frustum E_TRANSFORMATION_STATE

View Frustum depends on Projection & View Matrix

Definition at line 381 of file SViewFrustum.h.

        {
                u32 index = 0;
                switch ( state )
                {
                        case video::ETS_PROJECTION:
                                index = SViewFrustum::ETS_PROJECTION; break;
                        case video::ETS_VIEW:
                                index = SViewFrustum::ETS_VIEW; break;
                        default:
                                break;
                }
                return Matrices [ index ];
        }

recalculateBoundingBox()

void irr::scene::SViewFrustum::recalculateBoundingBox ( )

inline

recalculates the bounding box and sphere based on the planes

Definition at line 265 of file SViewFrustum.h.

        {
                boundingBox.reset(getNearLeftUp());
                boundingBox.addInternalPoint(getNearRightUp());
                boundingBox.addInternalPoint(getNearLeftDown());
                boundingBox.addInternalPoint(getNearRightDown());
                boundingBox.addInternalPoint(getFarRightUp());
                boundingBox.addInternalPoint(getFarLeftDown());
                boundingBox.addInternalPoint(getFarRightDown());
                boundingBox.addInternalPoint(getFarLeftUp());

                // Also recalculate the bounding sphere when the bbox changes
                recalculateBoundingSphere();
        }

setFarNearDistance()

void irr::scene::SViewFrustum::setFarNearDistance ( float  distance )

inline

the cam should tell the frustum the distance between far and near

Definition at line 290 of file SViewFrustum.h.

        {
                FarNearDistance = distance;
        }

setFrom()

void irr::scene::SViewFrustum::setFrom ( const core::matrix4 &  mat, bool  zClipFromZero  )

inline

This constructor creates a view frustum based on a projection and/or view matrix.

This constructor creates a view frustum based on a projection and/or view matrix.

Definition at line 297 of file SViewFrustum.h.

        {
                // left clipping plane
                planes[VF_LEFT_PLANE].Normal.X = mat[3 ] + mat[0];
                planes[VF_LEFT_PLANE].Normal.Y = mat[7 ] + mat[4];
                planes[VF_LEFT_PLANE].Normal.Z = mat[11] + mat[8];
                planes[VF_LEFT_PLANE].D =        mat[15] + mat[12];

                // right clipping plane
                planes[VF_RIGHT_PLANE].Normal.X = mat[3 ] - mat[0];
                planes[VF_RIGHT_PLANE].Normal.Y = mat[7 ] - mat[4];
                planes[VF_RIGHT_PLANE].Normal.Z = mat[11] - mat[8];
                planes[VF_RIGHT_PLANE].D =        mat[15] - mat[12];

                // top clipping plane
                planes[VF_TOP_PLANE].Normal.X = mat[3 ] - mat[1];
                planes[VF_TOP_PLANE].Normal.Y = mat[7 ] - mat[5];
                planes[VF_TOP_PLANE].Normal.Z = mat[11] - mat[9];
                planes[VF_TOP_PLANE].D =        mat[15] - mat[13];

                // bottom clipping plane
                planes[VF_BOTTOM_PLANE].Normal.X = mat[3 ] + mat[1];
                planes[VF_BOTTOM_PLANE].Normal.Y = mat[7 ] + mat[5];
                planes[VF_BOTTOM_PLANE].Normal.Z = mat[11] + mat[9];
                planes[VF_BOTTOM_PLANE].D =        mat[15] + mat[13];

                // far clipping plane
                planes[VF_FAR_PLANE].Normal.X = mat[3 ] - mat[2];
                planes[VF_FAR_PLANE].Normal.Y = mat[7 ] - mat[6];
                planes[VF_FAR_PLANE].Normal.Z = mat[11] - mat[10];
                planes[VF_FAR_PLANE].D =        mat[15] - mat[14];

                // near clipping plane
                if ( zClipFromZero )
                {
                        planes[VF_NEAR_PLANE].Normal.X = mat[2];
                        planes[VF_NEAR_PLANE].Normal.Y = mat[6];
                        planes[VF_NEAR_PLANE].Normal.Z = mat[10];
                        planes[VF_NEAR_PLANE].D =        mat[14];
                }
                else
                {
                        // near clipping plane
                        planes[VF_NEAR_PLANE].Normal.X = mat[3 ] + mat[2];
                        planes[VF_NEAR_PLANE].Normal.Y = mat[7 ] + mat[6];
                        planes[VF_NEAR_PLANE].Normal.Z = mat[11] + mat[10];
                        planes[VF_NEAR_PLANE].D =        mat[15] + mat[14];
                }

                // normalize normals
                u32 i;
                for ( i=0; i != VF_PLANE_COUNT; ++i)
                {
                        const f32 len = -core::reciprocal_squareroot(
                                        planes[i].Normal.getLengthSQ());
                        planes[i].Normal *= len;
                        planes[i].D *= len;
                }

                // make bounding box
                recalculateBoundingBox();
        }

transform()

void irr::scene::SViewFrustum::transform ( const core::matrix4 &  mat )

inline

transforms the frustum by the matrix

Parameters

mat	Matrix by which the view frustum is transformed.

Definition at line 170 of file SViewFrustum.h.

        {
                for (u32 i=0; i<VF_PLANE_COUNT; ++i)
                        mat.transformPlane(planes[i]);

                mat.transformVect(cameraPosition);
                recalculateBoundingBox();
        }

Member Data Documentation

boundingBox

core::aabbox3d<f32> irr::scene::SViewFrustum::boundingBox

bounding box around the view frustum

Definition at line 121 of file SViewFrustum.h.

cameraPosition

core::vector3df irr::scene::SViewFrustum::cameraPosition

the position of the camera

Definition at line 115 of file SViewFrustum.h.

planes

core::plane3d<f32> irr::scene::SViewFrustum::planes[VF_PLANE_COUNT]

all planes enclosing the view frustum.

Definition at line 118 of file SViewFrustum.h.

---

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

• include/irrlicht/SViewFrustum.h