SViewFrustum.hpp

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in nirtcpp/nirtcpp.hpp
 
#ifndef S_VIEW_FRUSTUM_HPP_INCLUDED
#define S_VIEW_FRUSTUM_HPP_INCLUDED
 
#include <nirtcpp/core/engine/plane3d.hpp>
#include <nirtcpp/core/engine/vector3d.hpp>
#include <nirtcpp/core/engine/line3d.hpp>
#include <nirtcpp/core/engine/aabbox3d.hpp>
#include <nirtcpp/core/engine/matrix4.hpp>
#include <nirtcpp/core/engine/IVideoDriver.hpp>
 
namespace nirt
{
namespace scene
{
 
 
    class SViewFrustum
    {
    public:
        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:
        SViewFrustum() : BoundingRadius(0.f), FarNearDistance(0.f) {}
 
        //\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);
 
    public:
        //\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;
 
    public:
 
        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 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 nirt
 
#endif