OgreCamera.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://ogre.sourceforge.net/

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 __Camera_H__
#define __Camera_H__

// Default options
#include "OgrePrerequisites.h"

#include "OgreString.h"
#include "OgreMovableObject.h"

// Matrices & Vectors
#include "OgreMatrix4.h"
#include "OgreVector3.h"
#include "OgrePlane.h"
#include "OgreQuaternion.h"
#include "OgreCommon.h"
#include "OgreFrustum.h"
#include "OgreRay.h"


namespace Ogre {



    class _OgreExport Camera : public Frustum
    {
    protected:
        String mName;
        SceneManager *mSceneMgr;

        Quaternion mOrientation;

        Vector3 mPosition;

        mutable Quaternion mDerivedOrientation;
        mutable Vector3 mDerivedPosition;

        mutable Quaternion mRealOrientation;
        mutable Vector3 mRealPosition;

        bool mYawFixed;
        Vector3 mYawFixedAxis;

        PolygonMode mSceneDetail;

        unsigned int mVisFacesLastRender;

        static String msMovableType;

        SceneNode* mAutoTrackTarget;
        Vector3 mAutoTrackOffset;

        // Scene LOD factor used to adjust overall LOD
        Real mSceneLodFactor;
        Real mSceneLodFactorInv;


        Real mWLeft, mWTop, mWRight, mWBottom;
        bool mWindowSet;
        mutable std::vector<Plane> mWindowClipPlanes;
        // Was viewing window changed.
        mutable bool mRecalcWindow;
        Viewport* mLastViewport;
        bool mAutoAspectRatio;
        Frustum *mCullFrustum;
        bool mUseRenderingDistance;


        // Internal functions for calcs
        bool isViewOutOfDate(void) const;
        void invalidateFrustum(void) const;
        void invalidateView(void) const;


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


    public:
        Camera( const String& name, SceneManager* sm);

        virtual ~Camera();


        SceneManager* getSceneManager(void) const;

        virtual const String& getName(void) const;


        void setPolygonMode(PolygonMode sd);

        PolygonMode getPolygonMode(void) const;

        void setPosition(Real x, Real y, Real z);

        void setPosition(const Vector3& vec);

        const Vector3& getPosition(void) const;

        void move(const Vector3& vec);

        void moveRelative(const Vector3& vec);

        void setDirection(Real x, Real y, Real z);

        void setDirection(const Vector3& vec);

        /* Gets the camera's direction.
        */
        Vector3 getDirection(void) const;

        Vector3 getUp(void) const;

        Vector3 getRight(void) const;

        void lookAt( const Vector3& targetPoint );
        void lookAt(Real x, Real y, Real z);

        void roll(const Radian& angle);
#ifndef OGRE_FORCE_ANGLE_TYPES
        void roll(Real degrees) { roll ( Angle(degrees) ); }
#endif//OGRE_FORCE_ANGLE_TYPES

        void yaw(const Radian& angle);
#ifndef OGRE_FORCE_ANGLE_TYPES
        void yaw(Real degrees) { yaw ( Angle(degrees) ); }
#endif//OGRE_FORCE_ANGLE_TYPES

        void pitch(const Radian& angle);
#ifndef OGRE_FORCE_ANGLE_TYPES
        void pitch(Real degrees) { pitch ( Angle(degrees) ); }
#endif//OGRE_FORCE_ANGLE_TYPES

        void rotate(const Vector3& axis, const Radian& angle);
#ifndef OGRE_FORCE_ANGLE_TYPES
        void rotate(const Vector3& axis, Real degrees) { rotate ( axis, Angle(degrees) ); }
#endif//OGRE_FORCE_ANGLE_TYPES

        void rotate(const Quaternion& q);

        void setFixedYawAxis( bool useFixed, const Vector3& fixedAxis = Vector3::UNIT_Y );


        const Quaternion& getOrientation(void) const;

        void setOrientation(const Quaternion& q);

        void _renderScene(Viewport *vp, bool includeOverlays);

        friend std::ostream& operator<<(std::ostream& o, Camera& c);

        void _notifyRenderedFaces(unsigned int numfaces);

        unsigned int _getNumRenderedFaces(void) const;

        const Quaternion& getDerivedOrientation(void) const;
        const Vector3& getDerivedPosition(void) const;
        Vector3 getDerivedDirection(void) const;
        Vector3 getDerivedUp(void) const;
        Vector3 getDerivedRight(void) const;

        const Quaternion& getRealOrientation(void) const;
        const Vector3& getRealPosition(void) const;
        Vector3 getRealDirection(void) const;
        Vector3 getRealUp(void) const;
        Vector3 getRealRight(void) const;

        const String& getMovableType(void) const;

        void setAutoTracking(bool enabled, SceneNode* target = 0, 
            const Vector3& offset = Vector3::ZERO);


        void setLodBias(Real factor = 1.0);

        Real getLodBias(void) const;



        Ray getCameraToViewportRay(Real screenx, Real screeny) const;

        Real _getLodBiasInverse(void) const;


        void _autoTrack(void);


        virtual void setWindow (Real Left, Real Top, Real Right, Real Bottom);
        virtual void resetWindow (void);
        virtual bool isWindowSet(void) const { return mWindowSet; }
        const std::vector<Plane>& getWindowPlanes(void) const;

        Real getBoundingRadius(void) const;
        SceneNode* getAutoTrackTarget(void) const { return mAutoTrackTarget; }
        const Vector3& getAutoTrackOffset(void) const { return mAutoTrackOffset; }
        
        Viewport* getViewport(void) const {return mLastViewport;}
        void _notifyViewport(Viewport* viewport) {mLastViewport = viewport;}

        void setAutoAspectRatio(bool autoratio);

        bool getAutoAspectRatio(void) const;

        void setCullingFrustum(Frustum* frustum) { mCullFrustum = frustum; }
        Frustum* getCullingFrustum(void) { return mCullFrustum; }

        bool isVisible(const AxisAlignedBox& bound, FrustumPlane* culledBy = 0) const;
        bool isVisible(const Sphere& bound, FrustumPlane* culledBy = 0) const;
        bool isVisible(const Vector3& vert, FrustumPlane* culledBy = 0) const;
        const Vector3* getWorldSpaceCorners(void) const;
        const Plane& getFrustumPlane( unsigned short plane ) const;
        bool projectSphere(const Sphere& sphere, 
            Real* left, Real* top, Real* right, Real* bottom) const;
        Real getNearClipDistance(void) const;
        Real getFarClipDistance(void) const;
        const Matrix4& getViewMatrix(void) const;
        const Matrix4& getViewMatrix(bool ownFrustumOnly) const;
        virtual void setUseRenderingDistance(bool use) { mUseRenderingDistance = use; }
        virtual bool getUseRenderingDistance(void) const { return mUseRenderingDistance; }
     };

} // namespace Ogre
#endif

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Mar 12 14:37:38 2006