freecamera.hpp

Go to the documentation of this file.

#ifndef __FREECAMERA__
#define __FREECAMERA__

#include <tucano/utils/flycamera.hpp>
#include <Eigen/Dense>
#include <cmath>

namespace Tucano
{

class Freecamera : public Tucano::Flycamera {
protected:
        
        float rotation_Z_axis;

public:

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

        void updateViewMatrix() override
        {
                Eigen::Vector3f xAxis = rotation_matrix.row(0);
                Eigen::Vector3f yAxis = rotation_matrix.row(1);
                Eigen::Vector3f zAxis = rotation_matrix.row(2);
                
                if( rotation_Z_axis )
                {
                        Eigen::AngleAxisf transfRotZ = Eigen::AngleAxisf(rotation_Z_axis, zAxis);
                        
                        // compute X axis restricted to a rotation around Z axis
                        xAxis = transfRotZ * xAxis;
                        xAxis.normalize();
                        
                        // compute Y axis restricted to a rotation around Z axis
                        yAxis = transfRotZ * yAxis;
                        yAxis.normalize();
                        
                        rotation_Z_axis = 0.0;
                }
                
                Eigen::AngleAxisf transfRotY = Eigen::AngleAxisf(rotation_Y_axis, yAxis);
                
                // compute X axis restricted to a rotation around Y axis
                Eigen::Vector3f rotX = transfRotY * xAxis;
                rotX.normalize();

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

                // rotate Y axis around X new axis
                Eigen::Vector3f rotY = transfRotX * yAxis;
                rotY.normalize();

                rotation_matrix.row(0) = rotX;
                rotation_matrix.row(1) = rotY;
                rotation_matrix.row(2) = rotZ;
                
                resetViewMatrix();
                view_matrix.rotate (rotation_matrix);
                view_matrix.translate (translation_vector);
                
                rotation_X_axis = 0.0;
                rotation_Y_axis = 0.0;
        }

    void strideLeft ( void ) override
    {
                translation_vector += rotation_matrix.row(0) * speed;
    }

    void strideRight ( void ) override
    {
                translation_vector -= rotation_matrix.row(0) * speed;
    }

    void moveBack ( void ) override
    {
                translation_vector -= rotation_matrix.row(2) * speed;
    }

    void moveForward ( void ) override
    {
                translation_vector += rotation_matrix.row(2) * speed;
    }

    void moveDown ( void ) override
    {
                translation_vector += rotation_matrix.row(1) * speed;
    }

    void moveUp ( void ) override
    {
                translation_vector -= rotation_matrix.row(1) * speed;
        }

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

                rotation_X_axis = dir2d[1]*M_PI;
                rotation_Y_axis = -dir2d[0]*M_PI;

        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;
        }
        
        void rotateZ ( Eigen::Vector2f new_mouse_pos ) override
        {
                Eigen::Vector2f new_position = normalizePosition(new_mouse_pos);
                Eigen::Vector2f dir2d = new_position - start_mouse_pos;
                
                start_mouse_pos = new_position;
                
                rotation_Z_axis = dir2d[1]*M_PI;
                
                if (rotation_Z_axis > 2*M_PI)
            rotation_Z_axis -= 2*M_PI;
        if (rotation_Z_axis < 0)
                        rotation_X_axis += 2*M_PI;
        }
        
};

}

#endif