flycamera.hpp

Go to the documentation of this file.

#ifndef __FLYCAMERA__
#define __FLYCAMERA__


#include <tucano/camera.hpp>
#include <tucano/shapes/coordinateaxes.hpp>
#include <Eigen/Dense>
#include <cmath>

namespace Tucano
{


class Flycamera : public Tucano::Camera {


protected:

    float speed;

        Eigen::Vector2f start_mouse_pos;
        
        Eigen::Matrix3f rotation_matrix;

    Eigen::Matrix3f default_rotation;

        Eigen::Vector3f translation_vector;

        // Default start translation vector
        Eigen::Vector3f default_translation;

        float rotation_Y_axis;
        float rotation_X_axis;

        // Coordiante axes for rendering flycamera orientation
        Tucano::Shapes::CoordinateAxes axes;

public:

    virtual void reset (void)
    {
                start_mouse_pos = Eigen::Vector2f::Zero();
                translation_vector = Eigen::Vector3f::Zero();
                rotation_matrix = Eigen::Matrix3f::Identity();
                default_translation = Eigen::Vector3f (0.0, 0.0, -2.0);
        default_rotation = Eigen::Matrix3f::Identity();
        rotation_X_axis = 0.0;
        rotation_Y_axis = 0.0;
                updateViewMatrix();
    }

    ~Flycamera() 
        {}

    void initOpenGLMatrices (void)
    {
        // reset all matrices
        reset();
    }

    Flycamera ()
    {
        speed = 0.05;
                reset();
        initOpenGLMatrices();

    }


    void setDefaultView (Eigen::Affine3f view)
    {
        default_rotation = view.rotation();
        default_translation = view.translation();

        cout << "R = " << endl << default_rotation << endl << endl;
        cout << "T = " << default_translation.transpose() << endl << endl;
    }

    Eigen::Vector3f getDefaultTranslation (void)
    {
        return default_translation;
    }


        void renderAtCorner (void)
        {
            float ratio = (viewport[2] - viewport[0]) / (viewport[3] - viewport[1]);
    
        Eigen::Matrix4f rep_projection_matrix = createOrthographicMatrix(-ratio, ratio, -1.0, 1.0, 0.1, 100.0);

        Eigen::Affine3f rep_view_matrix = Eigen::Affine3f::Identity();
        rep_view_matrix.translate( Eigen::Vector3f(1.0, -0.75, -5.0));
        
                Camera lightcam;

                Camera cam;
                cam.setViewMatrix(rep_view_matrix);
                cam.setProjectionMatrix(rep_projection_matrix);
                cam.setViewport(viewport);

                axes.resetModelMatrix();
                axes.modelMatrix()->rotate(rotation_matrix.inverse());
                axes.modelMatrix()->scale(0.3);
                axes.render(cam, lightcam);
        }


        virtual void updateViewMatrix()
        {
                resetViewMatrix();

                // compute X axis restricted to a rotation around Y axis
        Eigen::Vector3f rotX = Eigen::AngleAxisf(rotation_Y_axis, Eigen::Vector3f::UnitY()) * Eigen::Vector3f::UnitX();
        rotX.normalize();

        // rotate Z axis around Y axis, then rotate new Z axis around X new axis
        Eigen::Vector3f rotZ = Eigen::AngleAxisf(rotation_Y_axis, Eigen::Vector3f::UnitY()) * Eigen::Vector3f::UnitZ();
        rotZ = Eigen::AngleAxisf(rotation_X_axis, rotX) * rotZ;
        rotZ.normalize();

        // rotate Y axis around X new axis
                Eigen::Vector3f rotY = Eigen::AngleAxisf(rotation_X_axis, rotX) * Eigen::Vector3f::UnitY();
                rotY.normalize();

        rotation_matrix.row(0) = rotX;
        rotation_matrix.row(1) = rotY;
        rotation_matrix.row(2) = rotZ;

        view_matrix.rotate (default_rotation);
                view_matrix.rotate (rotation_matrix);
                view_matrix.translate (default_translation);
                view_matrix.translate (translation_vector);
        }       

    virtual void strideLeft ( void )
    {
                Eigen::Vector3f dir = (Eigen::AngleAxisf(rotation_Y_axis, Eigen::Vector3f::UnitY())) * Eigen::Vector3f(1.0, 0.0, 0.0);
                translation_vector += dir * speed;
    }

    virtual void strideRight ( void )
    {
                Eigen::Vector3f dir = (Eigen::AngleAxisf(rotation_Y_axis, Eigen::Vector3f::UnitY())) * Eigen::Vector3f(-1.0, 0.0, 0.0);
                translation_vector += dir * speed;
    }

    virtual void moveBack ( void )
    {
                Eigen::Vector3f dir = (Eigen::AngleAxisf(rotation_Y_axis, Eigen::Vector3f::UnitY())) * Eigen::Vector3f(0.0, 0.0, -1.0);
                translation_vector += dir * speed;
    }

    virtual void moveForward ( void )
    {
                Eigen::Vector3f dir = (Eigen::AngleAxisf(rotation_Y_axis, Eigen::Vector3f::UnitY())) * Eigen::Vector3f(0.0, 0.0, 1.0);
                translation_vector += dir * speed;
    }

    virtual void moveDown ( void )
    {
                translation_vector += Eigen::Vector3f::UnitY() * speed;
    }

    virtual void moveUp ( void )
    {
        translation_vector -= Eigen::Vector3f::UnitY() * speed;
        }

    Eigen::Vector2f normalizePosition (const Eigen::Vector2f& pos)
    {
        return Eigen::Vector2f ((pos[0]/((viewport[2]-viewport[0])/2.0)) - 1.0,
                                1.0 - (pos[1]/((viewport[3] - viewport[1])/2.0)));
    }

        void startRotation ( Eigen::Vector2f pos )
        {
                start_mouse_pos = normalizePosition ( pos );
        }       

        virtual void rotate ( Eigen::Vector2f new_mouse_pos )
        {
                Eigen::Vector2f new_position = normalizePosition(new_mouse_pos);
                Eigen::Vector2f dir2d = new_position - start_mouse_pos;
                
                start_mouse_pos = new_position;

                float anglex = -dir2d[1]*M_PI;
                float angley = -dir2d[0]*M_PI;
        
                rotation_X_axis += anglex;
                rotation_Y_axis += angley;

        if (rotation_X_axis > 2*M_PI)
            rotation_X_axis -= 2*M_PI;
        if (rotation_X_axis < 0)
            rotation_X_axis += 2*M_PI;
        if (rotation_Y_axis > 2*M_PI)
            rotation_Y_axis -= 2*M_PI;
        if (rotation_Y_axis < 0)
            rotation_Y_axis += 2*M_PI;
    
        }
        
        virtual void rotateZ ( Eigen::Vector2f new_mouse_pos )
        {}

        void setSpeed( const float& speed )
        { this->speed = speed; }
};

}
#endif