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-2005 The OGRE Team
Also see acknowledgements in Readme.html

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt.
-----------------------------------------------------------------------------
*/
#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 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;

        mutable Plane mFrustumPlanes[6];

        mutable Quaternion mLastParentOrientation;
        mutable Vector3 mLastParentPosition;

        mutable Matrix4 mProjMatrix;
        mutable Matrix4 mStandardProjMatrix;
        mutable Matrix4 mViewMatrix;
        mutable bool mRecalcFrustum;
        mutable bool mRecalcView;


        mutable Real mCoeffL[2], mCoeffR[2], mCoeffB[2], mCoeffT[2];



        
        // Internal functions for calcs
        virtual void updateFrustum(void) const;
        virtual void updateView(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;

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


    public:

        Frustum();
        virtual ~Frustum();
        virtual void setFOVy(const Radian& fovy);
#ifndef OGRE_FORCE_ANGLE_TYPES
        inline void setFOVy(Real fovy) {
            setFOVy ( Angle(fovy) );
        }
#endif//OGRE_FORCE_ANGLE_TYPES

        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 const Matrix4& getProjectionMatrix(void) const;
        virtual const Matrix4& getStandardProjectionMatrix(void) const;

        virtual const Matrix4& getViewMatrix(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;


        const AxisAlignedBox& getBoundingBox(void) const;

        Real getBoundingRadius(void) const;

        void _updateRenderQueue(RenderQueue* queue);

        const String& getMovableType(void) const;

        const String& getName(void) const;

        void _notifyCurrentCamera(Camera* cam);

        const MaterialPtr& getMaterial(void) const;

        void getRenderOperation(RenderOperation& op);

        void getWorldTransforms(Matrix4* xform) const;

        const Quaternion& getWorldOrientation(void) const;

        const Vector3& getWorldPosition(void) 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 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; }
        

        static const Real INFINITE_FAR_PLANE_ADJUST;
    };


}

#endif 

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Feb 12 12:59:45 2006