MyCamera.h

Go to the documentation of this file.

/******************************************************************************
 *
 *  Copyright (C) 2008 Boris Iven, Max Hermann
 *
 *  This file is part of the "CEDRIC Event Display" application.
 *
 *****************************************************************************/

#ifndef MYCAMERA
#define MYCAMERA

#include <osg/ref_ptr>
#include <osg/Vec3>
#include <osg/Quat>
#include <osg/Matrixd>
#include <osg/Camera>
#include <osg/BoundingBox>

#include <assert.h>

#include <list>

#define MYCAMERA_SUPPORT_QT

#ifdef MYCAMERA_SUPPORT_QT
 #include <QObject>
 class MyCamera : public QObject
 {
        Q_OBJECT        

 signals:
        void myCameraChanged();
        void myCameraChanged( MyCamera* );
 private:       
#else
 class MyCamera
 {
#endif
public:
        enum Projection { 
                                ORTHOGRAPHIC, 
                                PERSPECTIVE   
                        };      
        
        struct Frustum 
        { 
                float left,right,bottom,top,zNear,zFar;
                
                Frustum()
                        : left(-1.f),right(1.f),bottom(-1.f),top(1.f),zNear(-1.f),zFar(1.f)
                        {}
                                
                Frustum( float l, float r, float b, float t, float n, float f )
                        : left(l),right(r),bottom(b),top(t),zNear(n),zFar(f)
                        {}
        };
        
        MyCamera();
        virtual ~MyCamera() {}
  #ifdef MYCAMERA_SUPPORT_QT // QObject should be explicitly initialized in copy contructor
        MyCamera( const MyCamera& other ):QObject() { setLike( other ); }
  #else
        MyCamera( const MyCamera& other ) { setLike( other ); }
  #endif
        MyCamera& operator = ( const MyCamera& other )  { if( this!=&other ) setLike(other); return *this; }
        void setLike( const MyCamera& other )
        {
                m_projection = other.getProjection();
                m_fov        = other.getFov();
                m_aspect     = other.getAspect();
                getLookAt( m_eye, m_center, m_up );
                m_rotation   = other.rotation();                
                m_camera     = other.getCamera();               
                m_autoComputeAspect = other.isAutoComputeAspect();              
        }
        
        void setProjection( int proj )
        {
                switch( proj )
                {
                default:
                case PERSPECTIVE:  m_projection=PERSPECTIVE;  break;
                case ORTHOGRAPHIC: m_projection=ORTHOGRAPHIC; break;
                }               
                
                update();
        }
        int getProjection() const { return m_projection; }
        
        void setFov( float fov ) { m_fov = fov; updateProj(); } 
        void setAspect( float aspect, bool autoComputeAspect=false ) { m_aspect=aspect; m_autoComputeAspect=autoComputeAspect; updateProj(); }  
        void setFovAspect( float fov, float aspect, bool autoComputeAspect=false ) { m_fov=fov; m_aspect=aspect; m_autoComputeAspect=autoComputeAspect; updateProj(); }
        void enableAutoComputeAspect() { m_autoComputeAspect = false; }
        bool isAutoComputeAspect() const { return m_autoComputeAspect; }
        
        void setLookAt( osg::Vec3 eye, osg::Vec3 center, osg::Vec3 up );
        void setDistance( float dist )
        {
                // rotation is not affected
                m_eye = m_center - north()*dist;
                updateView();
        }
        void setRotation( osg::Quat q ); //{ m_rotation = q; updateView(); }
        void setCenter( osg::Vec3 center )
        {
                // rotation is changed!
                setLookAt( m_eye, center, m_up );
        }
        
        void translate( osg::Vec3 t ) { m_center+=t; m_eye+=t; updateView(); }
        void pan( float dx, float dy );
        void zoom( int x0, int y0, int x1, int y1 );
        
        void zoom( const osg::BoundingBox& bbox );

        void apply( osg::Camera* cam ) const;
        
        inline float getFov() const { return m_fov; }
        inline float getAspect() const { return m_aspect; }

        inline osg::Quat rotation() const { return m_rotation; }
        inline float distance() const { return los().length(); }
        inline osg::Vec3 los() const { return m_center - m_eye; }       
        inline osg::Vec3 north() const { osg::Vec3 n(m_center-m_eye); n.normalize(); return n; }
        inline osg::Vec3 east() const { osg::Vec3 s=north() ^ m_up; s.normalize(); return s; }
        inline osg::Vec3 up() const { return m_up; }
        inline osg::Vec3 center() const { return m_center; }


        inline void getLookAt( osg::Vec3& eye, osg::Vec3& center, osg::Vec3& up  ) const 
                { eye=m_eye; center=m_center; up=m_up; }
        

        void updateView() { update(); }

        void updateProj() { update(); }
                
        void update();
                
        void associate( osg::Camera* cam ) { m_camera=cam; update(); }
        osg::Camera* getCamera() const { return m_camera.get(); }
        
        void setLikeCamera( osg::Camera* cam );
        
        
        void link( MyCamera* other );
        void unlink( MyCamera* other );
        void unlinkAll() { m_linked.clear(); }
        
        
        void setFixedOrientation( bool fixed ) { m_fixedOrientation = fixed; }
        bool isFixedOrientation() const { return m_fixedOrientation; }
        
        

        osg::Vec3 unproject( int x, int y, osg::Camera* cam=0 ) const;


        osg::Matrixd getViewMatrix() const;
        
        osg::Matrixd getInverseViewMatrix() const;
        

protected:
        Frustum makeFrustum() const;
        
        // HACK
        void disableNextUpdate() { m_disableNextUpdate = true; }

private:
        int m_projection;
        float m_fov, m_aspect;
        osg::Vec3 m_eye, m_center, m_up;
        osg::Quat m_rotation; 

        osg::ref_ptr<osg::Camera> m_camera;
        
        std::list<MyCamera*> m_linked;

        bool m_autoComputeAspect;
        bool m_disableNextUpdate;
        bool m_fixedOrientation;
};

#endif