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://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 __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"
#include "OgrePlaneBoundedVolume.h"


namespace Ogre {

    class _OgreExport Camera : public Frustum
    {
    public:
        class _OgreExport Listener 
        {
        public:
            Listener() {}
            virtual ~Listener() {}

            virtual void cameraPreRenderScene(Camera* cam)
                        { (void)cam; }

            virtual void cameraPostRenderScene(Camera* cam)
                        { (void)cam; }

            virtual void cameraDestroyed(Camera* cam)
                        { (void)cam; }

        };
    protected:
        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;

        unsigned int mVisBatchesLastRender;

        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 vector<Plane>::type mWindowClipPlanes;
        // Was viewing window changed.
        mutable bool mRecalcWindow;
        Viewport* mLastViewport;
        bool mAutoAspectRatio;
        Frustum *mCullFrustum;
        bool mUseRenderingDistance;
        const Camera* mLodCamera;
        
        bool mUseMinPixelSize;
        Real mPixelDisplayRatio;

        typedef vector<Listener*>::type ListenerList;
        ListenerList mListeners;


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


        virtual void setWindowImpl(void) const;

        virtual vector<Vector4>::type getRayForwardIntersect(const Vector3& anchor, const Vector3 *dir, Real planeOffset) const;

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

        virtual ~Camera();

        virtual void addListener(Listener* l);
        virtual void removeListener(Listener* l);

        SceneManager* getSceneManager(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);

        void yaw(const Radian& angle);

        void pitch(const Radian& angle);

        void rotate(const Vector3& axis, const Radian& angle);

        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);

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

        void _notifyRenderedFaces(unsigned int numfaces);

        void _notifyRenderedBatches(unsigned int numbatches);

        unsigned int _getNumRenderedFaces(void) const;

        unsigned int _getNumRenderedBatches(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;

        void getWorldTransforms(Matrix4* mat) const;

        const String& getMovableType(void) const;

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


        void setLodBias(Real factor = 1.0);

        Real getLodBias(void) const;

        virtual void setLodCamera(const Camera* lodCam);

        virtual const Camera* getLodCamera() const;


        Ray getCameraToViewportRay(Real screenx, Real screeny) const;
        void getCameraToViewportRay(Real screenx, Real screeny, Ray* outRay) const;

        PlaneBoundedVolume getCameraToViewportBoxVolume(Real screenLeft, 
            Real screenTop, Real screenRight, Real screenBottom, bool includeFarPlane = false);

        void getCameraToViewportBoxVolume(Real screenLeft, 
            Real screenTop, Real screenRight, Real screenBottom, 
            PlaneBoundedVolume* outVolume, bool includeFarPlane = false);

        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 vector<Plane>::type& 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) const { return mCullFrustum; }

        virtual void forwardIntersect(const Plane& worldPlane, vector<Vector4>::type* intersect3d) const;

        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; }

        virtual void synchroniseBaseSettingsWith(const Camera* cam);

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

        void setUseMinPixelSize(bool enable) { mUseMinPixelSize = enable; }
        bool getUseMinPixelSize() const { return mUseMinPixelSize; }

        Real getPixelDisplayRatio() const { return mPixelDisplayRatio; }
        
     };
} // namespace Ogre
#endif