SViewFrustum.h

Go to the documentation of this file.

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h

#ifndef __S_VIEW_FRUSTUM_H_INCLUDED__
#define __S_VIEW_FRUSTUM_H_INCLUDED__

#include "plane3d.h"
#include "vector3d.h"
#include "line3d.h"
#include "aabbox3d.h"
#include "matrix4.h"
#include "IVideoDriver.h"

namespace irr
{
namespace scene
{


        struct SViewFrustum
        {
                enum VFPLANES
                {
                        VF_FAR_PLANE = 0,
                        VF_NEAR_PLANE,
                        VF_LEFT_PLANE,
                        VF_RIGHT_PLANE,
                        VF_BOTTOM_PLANE,
                        VF_TOP_PLANE,

                        VF_PLANE_COUNT
                };


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

                SViewFrustum(const SViewFrustum& other);

                //\param zClipFromZero: Clipping of z can be projected from 0 to w when true (D3D style) and from -w to w when false (OGL style).
                SViewFrustum(const core::matrix4& mat, bool zClipFromZero);

                //\param zClipFromZero: Clipping of z can be projected from 0 to w when true (D3D style) and from -w to w when false (OGL style).
                inline void setFrom(const core::matrix4& mat, bool zClipFromZero);


                void transform(const core::matrix4& mat);

                core::vector3df getFarLeftUp() const;

                core::vector3df getFarLeftDown() const;

                core::vector3df getFarRightUp() const;

                core::vector3df getFarRightDown() const;

                core::vector3df getNearLeftUp() const;

                core::vector3df getNearLeftDown() const;

                core::vector3df getNearRightUp() const;

                core::vector3df getNearRightDown() const;

                const core::aabbox3d<f32> &getBoundingBox() const;

                inline void recalculateBoundingBox();

                float getBoundingRadius() const;

                core::vector3df getBoundingCenter() const;

                void setFarNearDistance(float distance);

                core::matrix4& getTransform( video::E_TRANSFORMATION_STATE state);

                const core::matrix4& getTransform( video::E_TRANSFORMATION_STATE state) const;


                bool clipLine(core::line3d<f32>& line) const;

                core::vector3df cameraPosition;

                core::plane3d<f32> planes[VF_PLANE_COUNT];

                core::aabbox3d<f32> boundingBox;

        private:
                enum E_TRANSFORMATION_STATE_FRUSTUM
                {
                        ETS_VIEW = 0,
                        ETS_PROJECTION = 1,
                        ETS_COUNT_FRUSTUM
                };

                inline void recalculateBoundingSphere();

                core::matrix4 Matrices[ETS_COUNT_FRUSTUM];

                float BoundingRadius;
                float FarNearDistance;
                core::vector3df BoundingCenter;
        };


        inline SViewFrustum::SViewFrustum(const SViewFrustum& other)
        {
                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;
        }

        inline SViewFrustum::SViewFrustum(const core::matrix4& mat, bool zClipFromZero)
        {
                setFrom(mat, zClipFromZero);
        }


        inline void SViewFrustum::transform(const core::matrix4& mat)
        {
                for (u32 i=0; i<VF_PLANE_COUNT; ++i)
                        mat.transformPlane(planes[i]);

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


        inline core::vector3df SViewFrustum::getFarLeftUp() const
        {
                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;
        }

        inline core::vector3df SViewFrustum::getFarLeftDown() const
        {
                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;
        }

        inline core::vector3df SViewFrustum::getFarRightUp() const
        {
                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;
        }

        inline core::vector3df SViewFrustum::getFarRightDown() const
        {
                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;
        }

        inline core::vector3df SViewFrustum::getNearLeftUp() const
        {
                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;
        }

        inline core::vector3df SViewFrustum::getNearLeftDown() const
        {
                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;
        }

        inline core::vector3df SViewFrustum::getNearRightUp() const
        {
                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;
        }

        inline core::vector3df SViewFrustum::getNearRightDown() const
        {
                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;
        }

        inline const core::aabbox3d<f32> &SViewFrustum::getBoundingBox() const
        {
                return boundingBox;
        }

        inline void SViewFrustum::recalculateBoundingBox()
        {
                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();
        }

        inline float SViewFrustum::getBoundingRadius() const
        {
                return BoundingRadius;
        }

        inline core::vector3df SViewFrustum::getBoundingCenter() const
        {
                return BoundingCenter;
        }

        inline void SViewFrustum::setFarNearDistance(float distance)
        {
                FarNearDistance = distance;
        }

        inline void SViewFrustum::setFrom(const core::matrix4& mat, bool zClipFromZero)
        {
                // 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();
        }

        inline core::matrix4& SViewFrustum::getTransform(video::E_TRANSFORMATION_STATE state)
        {
                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 ];
        }

        inline const core::matrix4& SViewFrustum::getTransform(video::E_TRANSFORMATION_STATE state) const
        {
                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 ];
        }

        inline bool SViewFrustum::clipLine(core::line3d<f32>& line) const
        {
                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;
        }

        inline void SViewFrustum::recalculateBoundingSphere()
        {
                // Find the center
                const float shortlen = (getNearLeftUp() - getNearRightUp()).getLength();
                const float longlen = (getFarLeftUp() - getFarRightUp()).getLength();

                const float farlen = FarNearDistance;
                const float fartocenter = (farlen + (shortlen - longlen) * (shortlen + longlen)/(4*farlen)) / 2;
                const float neartocenter = farlen - fartocenter;

                BoundingCenter = cameraPosition + -planes[VF_NEAR_PLANE].Normal * neartocenter;

                // Find the radius
                core::vector3df dir[8];
                dir[0] = getFarLeftUp() - BoundingCenter;
                dir[1] = getFarRightUp() - BoundingCenter;
                dir[2] = getFarLeftDown() - BoundingCenter;
                dir[3] = getFarRightDown() - BoundingCenter;
                dir[4] = getNearRightDown() - BoundingCenter;
                dir[5] = getNearLeftDown() - BoundingCenter;
                dir[6] = getNearRightUp() - BoundingCenter;
                dir[7] = getNearLeftUp() - BoundingCenter;

                u32 i = 0;
                float diam[8] = { 0.f };

                for (i = 0; i < 8; ++i)
                        diam[i] = dir[i].getLengthSQ();

                float longest = 0;

                for (i = 0; i < 8; ++i)
                {
                        if (diam[i] > longest)
                                longest = diam[i];
                }

                BoundingRadius = sqrtf(longest);
        }

} // end namespace scene
} // end namespace irr

#endif