OgreFrustum.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OGRE
    (Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/

Copyright (c) 2000-2012 Torus Knot Software Ltd

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
-----------------------------------------------------------------------------
*/
#ifndef __Frustum_H__
#define __Frustum_H__

#include "OgrePrerequisites.h"
#include "OgreMovableObject.h"
#include "OgreRenderable.h"
#include "OgreAxisAlignedBox.h"
#include "OgreVertexIndexData.h"
#include "OgreMovablePlane.h"

namespace Ogre
{
    enum OrientationMode
    {
        OR_DEGREE_0       = 0,
        OR_DEGREE_90      = 1,
        OR_DEGREE_180     = 2,
        OR_DEGREE_270     = 3,

        OR_PORTRAIT       = OR_DEGREE_0,
        OR_LANDSCAPERIGHT = OR_DEGREE_90,
        OR_LANDSCAPELEFT  = OR_DEGREE_270
    };

    enum ProjectionType
    {
        PT_ORTHOGRAPHIC,
        PT_PERSPECTIVE
    };

    enum FrustumPlane
    {
        FRUSTUM_PLANE_NEAR   = 0,
        FRUSTUM_PLANE_FAR    = 1,
        FRUSTUM_PLANE_LEFT   = 2,
        FRUSTUM_PLANE_RIGHT  = 3,
        FRUSTUM_PLANE_TOP    = 4,
        FRUSTUM_PLANE_BOTTOM = 5
    };

    class _OgreExport Frustum : public MovableObject, public Renderable
    {
    protected:
        ProjectionType mProjType;

        Radian mFOVy;
        Real mFarDist;
        Real mNearDist;
        Real mAspect;
        Real mOrthoHeight;
        Vector2 mFrustumOffset;
        Real mFocalLength;

        mutable Plane mFrustumPlanes[6];

        mutable Quaternion mLastParentOrientation;
        mutable Vector3 mLastParentPosition;

        mutable Matrix4 mProjMatrixRS;
        mutable Matrix4 mProjMatrixRSDepth;
        mutable Matrix4 mProjMatrix;
        mutable Matrix4 mViewMatrix;
        mutable bool mRecalcFrustum;
        mutable bool mRecalcView;
        mutable bool mRecalcFrustumPlanes;
        mutable bool mRecalcWorldSpaceCorners;
        mutable bool mRecalcVertexData;
        bool mCustomViewMatrix;
        bool mCustomProjMatrix;
        bool mFrustumExtentsManuallySet;
        mutable Real mLeft, mRight, mTop, mBottom;
        mutable OrientationMode mOrientationMode;
        
        // Internal functions for calcs
        virtual void calcProjectionParameters(Real& left, Real& right, Real& bottom, Real& top) const;
        virtual void updateFrustum(void) const;
        virtual void updateView(void) const;
        virtual void updateFrustumImpl(void) const;
        virtual void updateViewImpl(void) const;
        virtual void updateFrustumPlanes(void) const;
        virtual void updateFrustumPlanesImpl(void) const;
        virtual void updateWorldSpaceCorners(void) const;
        virtual void updateWorldSpaceCornersImpl(void) const;
        virtual void updateVertexData(void) const;
        virtual bool isViewOutOfDate(void) const;
        virtual bool isFrustumOutOfDate(void) const;
        virtual void invalidateFrustum(void) const;
        virtual void invalidateView(void) const;

        static String msMovableType;

        mutable AxisAlignedBox mBoundingBox;
        mutable VertexData mVertexData;

        MaterialPtr mMaterial;
        mutable Vector3 mWorldSpaceCorners[8];

        bool mReflect;
        mutable Matrix4 mReflectMatrix;
        mutable Plane mReflectPlane;
        const MovablePlane* mLinkedReflectPlane;
        mutable Plane mLastLinkedReflectionPlane;
        
        bool mObliqueDepthProjection;
        mutable Plane mObliqueProjPlane;
        const MovablePlane* mLinkedObliqueProjPlane;
        mutable Plane mLastLinkedObliqueProjPlane;

    public:

        Frustum(const String& name = StringUtil::BLANK);

        virtual ~Frustum();
        virtual void setFOVy(const Radian& fovy);

        virtual const Radian& getFOVy(void) const;

        virtual void setNearClipDistance(Real nearDist);

        virtual Real getNearClipDistance(void) const;

        virtual void setFarClipDistance(Real farDist);

        virtual Real getFarClipDistance(void) const;

        virtual void setAspectRatio(Real ratio);

        virtual Real getAspectRatio(void) const;

        virtual void setFrustumOffset(const Vector2& offset);

        virtual void setFrustumOffset(Real horizontal = 0.0, Real vertical = 0.0);

        virtual const Vector2& getFrustumOffset() const;

        virtual void setFocalLength(Real focalLength = 1.0);

        virtual Real getFocalLength() const;

        virtual void setFrustumExtents(Real left, Real right, Real top, Real bottom);
        virtual void resetFrustumExtents(); 
        virtual void getFrustumExtents(Real& outleft, Real& outright, Real& outtop, Real& outbottom) const;


        virtual const Matrix4& getProjectionMatrixRS(void) const;
        virtual const Matrix4& getProjectionMatrixWithRSDepth(void) const;
        virtual const Matrix4& getProjectionMatrix(void) const;

        virtual const Matrix4& getViewMatrix(void) const;

        virtual void calcViewMatrixRelative(const Vector3& relPos, Matrix4& matToUpdate) const;

        virtual void setCustomViewMatrix(bool enable, 
            const Matrix4& viewMatrix = Matrix4::IDENTITY);
        virtual bool isCustomViewMatrixEnabled(void) const 
        { return mCustomViewMatrix; }
        
        virtual void setCustomProjectionMatrix(bool enable, 
            const Matrix4& projectionMatrix = Matrix4::IDENTITY);
        virtual bool isCustomProjectionMatrixEnabled(void) const
        { return mCustomProjMatrix; }

        virtual const Plane* getFrustumPlanes(void) const;

        virtual const Plane& getFrustumPlane( unsigned short plane ) const;

        virtual bool isVisible(const AxisAlignedBox& bound, FrustumPlane* culledBy = 0) const;

        virtual bool isVisible(const Sphere& bound, FrustumPlane* culledBy = 0) const;

        virtual bool isVisible(const Vector3& vert, FrustumPlane* culledBy = 0) const;

        uint32 getTypeFlags(void) const;

        const AxisAlignedBox& getBoundingBox(void) const;

        Real getBoundingRadius(void) const;

        void _updateRenderQueue(RenderQueue* queue);

        const String& getMovableType(void) const;

        void _notifyCurrentCamera(Camera* cam);

        const MaterialPtr& getMaterial(void) const;

        void getRenderOperation(RenderOperation& op);

        void getWorldTransforms(Matrix4* xform) const;

        Real getSquaredViewDepth(const Camera* cam) const;

        const LightList& getLights(void) const;

        virtual const Vector3* getWorldSpaceCorners(void) const;

        virtual void setProjectionType(ProjectionType pt);

        virtual ProjectionType getProjectionType(void) const;

        virtual void setOrthoWindow(Real w, Real h);
        virtual void setOrthoWindowHeight(Real h);
        virtual void setOrthoWindowWidth(Real w);
        virtual Real getOrthoWindowHeight() const;
        virtual Real getOrthoWindowWidth() const;

        virtual void enableReflection(const Plane& p);
        virtual void enableReflection(const MovablePlane* p);

        virtual void disableReflection(void);

        virtual bool isReflected(void) const { return mReflect; }
        virtual const Matrix4& getReflectionMatrix(void) const { return mReflectMatrix; }
        virtual const Plane& getReflectionPlane(void) const { return mReflectPlane; }

        virtual bool projectSphere(const Sphere& sphere, 
            Real* left, Real* top, Real* right, Real* bottom) const;


        virtual void enableCustomNearClipPlane(const MovablePlane* plane);
        virtual void enableCustomNearClipPlane(const Plane& plane);
        virtual void disableCustomNearClipPlane(void);
        virtual bool isCustomNearClipPlaneEnabled(void) const 
        { return mObliqueDepthProjection; }

        void visitRenderables(Renderable::Visitor* visitor, 
            bool debugRenderables = false);

        static const Real INFINITE_FAR_PLANE_ADJUST;

        virtual const Vector3& getPositionForViewUpdate(void) const;
        virtual const Quaternion& getOrientationForViewUpdate(void) const;

        PlaneBoundedVolume getPlaneBoundedVolume();
        void setOrientationMode(OrientationMode orientationMode);

        OrientationMode getOrientationMode() const;

    };

}

#endif