trackball.hpp

Go to the documentation of this file.

#ifndef __TRACKBALL__
#define __TRACKBALL__

#include <tucano/camera.hpp>
#include <tucano/utils/math.hpp>
#include <tucano/shapes/arrow.hpp>
#include <Eigen/Dense>
#include <cmath>

namespace Tucano
{

const string trackball_fragment_code = "\n"
        "#version 430\n"
        "in vec4 ex_Color;\n"
        "out vec4 out_Color;\n"
        "in float depth;\n"
        "void main(void)\n"
        "{\n"
        "    out_Color = ex_Color;\n"
        "    gl_FragDepth = depth;\n"
        "}\n";

const string trackball_vertex_code = "\n"
        "#version 430\n"
        "layout(location=0) in vec4 in_Position;\n"
        "out vec4 ex_Color;\n"
        "out float depth;\n"
        "uniform mat4 modelMatrix;\n"
        "uniform mat4 viewMatrix;\n"
        "uniform mat4 projectionMatrix;\n"
        "uniform vec4 in_Color;\n"
        "uniform float nearPlane;\n"
        "uniform float farPlane;\n"
        "void main(void)\n"
        "{\n"
        "   vec4 pos = (viewMatrix * modelMatrix) * in_Position;\n"
        "   depth = (farPlane+nearPlane)/(farPlane-nearPlane) + ( (2*nearPlane*farPlane)/(farPlane-nearPlane) ) * (1/pos[2]);\n"
        "   depth = (depth+1.0)/2.0;\n"
        "   gl_Position = projectionMatrix * pos;\n"
        "   ex_Color = in_Color;\n"
        "}\n";

class Trackball : public Tucano::Camera {


protected:
    float zoom = 1.0;

    bool rotating = false;

    bool translating = false;

    bool drawTrackball = true;

    Eigen::Matrix4f trackballProjectionMatrix;

    Eigen::Vector3f initialPosition;

    Eigen::Vector3f finalPosition;

    Eigen::Vector2f initialTranslationPosition;

    Eigen::Vector2f finalTranslationPosition;

    Eigen::Quaternion<float> quaternion;

    Eigen::Quaternion<float> default_quaternion;

    Eigen::Vector3f translationVector;

    Eigen::Vector3f default_translation = Eigen::Vector3f (0.0, 0.0, -4.0);


    Tucano::Shader trackball_shader;

    Tucano::Mesh mesh;

    float radius = 0.8;

    bool use_default_shaders;

public:

    Trackball (string shader_dir = "")
    {
        // initialize the shader used for trackball rendering:
        if (shader_dir.empty())
        {
                trackball_shader.setShaderName("trackballShader");
            use_default_shaders = true;
        }
        else
        {
            trackball_shader.load("trackballShader", shader_dir);
            use_default_shaders = false;
        }

        // creates the mesh that will be used to represent the trackball's sphere.
        createTrackballRepresentation();

        initOpenGLMatrices();
        loadShader();
        reset();
    }



    void reset (void)
    {
        quaternion = Eigen::Quaternion<float>::Identity();
        default_quaternion = Eigen::Quaternion<float>::Identity();
        zoom = 1.0;
        translationVector << 0.0, 0.0, 0.0;
        rotating = false;
        translating = false;
        Tucano::Camera::resetViewMatrix();
        updateViewMatrix();
    }

    bool isRotating (void)
    {
        return rotating;
    }

    bool isTranslating (void)
    {
        return translating;
    }

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

    void setDefaultTranslation (Eigen::Vector3f t)
    {
        default_translation = t;
    }


    Eigen::Quaternion<float> getDefaultRotation (void)
    {
        return default_quaternion;
    }


    virtual Eigen::Quaternion<float> getRotation (void)
    {
        return quaternion*default_quaternion;
    }

    void setDefaultRotation (Eigen::Matrix3f rot)
    {
        default_quaternion = rot;
    }


    virtual void setRadius (float r)
    {
        radius = r;
    }

    float getZoom (void)
    {
        return zoom;
    }


    void setTrackballProjectionMatrix (const Eigen::Matrix4f& mat)
    {
        trackballProjectionMatrix = mat;
    }


    virtual void endRotation (void)
    {
        rotating = false;
    }

    void endTranslation (void)
    {
        translating = false;
    }



    void setRenderFlag(bool flag)
    {
        drawTrackball = flag;
    }

    void loadShader (void)
    {
        if (use_default_shaders)
        {
            trackball_shader.initializeFromStrings(trackball_vertex_code, trackball_fragment_code);
        }
        else
        {
            trackball_shader.initialize();
        }
    }

private:

    virtual Eigen::Vector3f computeSpherePosition (const Eigen::Vector2f& pos)
    {
        //In order to handle points outside the sphere, we will use two surfaces: A Sphere with radius = 0.8 and a Hyperbolic Sheet. More information about this usage in: http://www.opengl.org/wiki/Trackball.
        float z;

        Eigen::Vector2f p = pos;
        float r = radius;

        //If pos corresponds to a point before the intersection of the two surfaces, z can be calculated by the Sphere's equation.
        if(p[0]*p[0] + p[1]*p[1] <= (r*r)/2.0) {
            z = sqrt(r*r - p[0]*p[0] - p[1]*p[1]);
        }

        //Else, it will be calculated by the Hyperbolic Sheet's equation.
        else {
            z = (r*r)/(2.0*sqrt(p[0]*p[0] + p[1]*p[1]));
        }

        Eigen::Vector3f position = Eigen::Vector3f(p[0], p[1], z);

        return position;
    }

public:

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

        // translate viewMatrix outside the origin to be able to see the model.
        translate(default_translation);

        trackballProjectionMatrix = Eigen::Matrix4f::Identity();
    }

    Eigen::Matrix4f setTrackballPerspectiveMatrix (float fy, float aspect_ratio, float near_plane, float far_plane)
    {
        Eigen::Matrix4f proj = createPerspectiveMatrix(fy, aspect_ratio, near_plane, far_plane);
        setTrackballProjectionMatrix(proj);
        return proj;
    }

    Eigen::Matrix4f setTrackballOrthographicMatrix (float left, float right, float bottom, float top, float near_plane, float far_plane)
    {
        Eigen::Matrix4f proj = createOrthographicMatrix(left, right, bottom, top, near_plane, far_plane);
        setTrackballProjectionMatrix(proj);
        return proj;
    }

    virtual Eigen::Quaternion<float> computeRotationAngle (float sensibility = 1.0)
    {
        //Given two position vectors, corresponding to the initial and final mouse coordinates, calculate the rotation of the sphere that will keep the mouse always in the initial position.

        if(initialPosition.norm() > 0) {
            initialPosition.normalize();
        }
        if(finalPosition.norm() > 0) {
            finalPosition.normalize();
        }

        Eigen::Vector3f rotationAxis = initialPosition.cross(finalPosition);

        if(rotationAxis.norm() != 0) {
            rotationAxis.normalize();
        }

        float dot = initialPosition.dot(finalPosition);

        float rotationAngle = (dot <= 1) ? acos(dot) : 0;//If, by losing floating point precision, the dot product between the initial and final positions is bigger than one, ignore the rotation.

        rotationAngle *= sensibility;
        Eigen::Quaternion<float> q (Eigen::AngleAxis<float>(rotationAngle,rotationAxis));
        quaternion = q * quaternion;
        quaternion.normalize();
        return q;
    }

    virtual Eigen::Vector3f computeTranslationVector (void)
    {
        Eigen::Vector2f translationFactor = finalTranslationPosition - initialTranslationPosition;
        Eigen::Vector3f inc = quaternion.inverse() * Eigen::Vector3f(translationFactor[0],translationFactor[1], 0.0);

        translationVector += inc;
        return inc;
    }

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

    virtual Eigen::Quaternion<float> rotateCamera (const Eigen::Vector2f& pos)
    {
        Eigen::Vector3f normalized_pos = computeSpherePosition(normalizePosition(pos));

        Eigen::Quaternion<float> increment = Eigen::Quaternion<float>::Identity(); 

        if (!rotating)
        {
            rotating = true;
            initialPosition = normalized_pos;
        }
        else if ( pos != initialPosition.head(2))
        {
            finalPosition = normalized_pos;
            increment = computeRotationAngle();
            updateViewMatrix();
            initialPosition = finalPosition;
        }
        return increment;
    }

    virtual Eigen::Vector3f translateCamera (const Eigen::Vector2f& pos)
    {
        Eigen::Vector2f normalized_pos = normalizePosition(pos);
        Eigen::Vector3f increment = Eigen::Vector3f::Zero();
        if (!translating)
        {
            translating = true;
            initialTranslationPosition = normalized_pos;
        }
        else if (pos != initialPosition.head(2))
        {
            finalTranslationPosition = normalized_pos;
            increment = computeTranslationVector();
            updateViewMatrix();
            initialTranslationPosition = finalTranslationPosition;
        }
        return increment;
    }


    void increaseZoom (float scale)
    {
        zoom *= scale;
        updateViewMatrix();
    }

    void decreaseZoom (float scale)
    {
        zoom /= scale;
        updateViewMatrix();
    }

    void applyScaleToViewMatrix (float scale)
    {
        zoom = scale;
        updateViewMatrix();
    }

    void translateViewMatrix (const Eigen::Vector3f& translation)
    {
        translationVector += translation;
    }

    void rotateViewMatrix (const Eigen::Affine3f &rot)
    {
        Eigen::Quaternion<float> q (rot.rotation().matrix()); 
        quaternion *= q;
        quaternion.normalize();
    }

   
    virtual void updateViewMatrix (void)
    {
        resetViewMatrix();
        rotate(default_quaternion);
        translate(default_translation);
        rotate(quaternion);
        translate(translationVector);
        scale(zoom);
    }

    void createTrackballRepresentation (void)
    {
        vector < Eigen::Vector4f > vertices;

        for (float theta = 0; theta<2*M_PI; theta += (2*M_PI)/200.0)
        {
            vertices.push_back ( Eigen::Vector4f (cos(theta), sin(theta), 0.0, 1.0) );
        }
        mesh.loadVertices(vertices);
        mesh.setDefaultAttribLocations();
    }


    virtual void render (Eigen::Affine3f ext_view_matrix = Eigen::Affine3f::Identity(), Eigen::Matrix4f ext_proj_matrix = Eigen::Matrix4f::Identity())
    {
        if(drawTrackball)
        {
            glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);

            float ratio = (viewport[2]) / (viewport[3]);
            setTrackballOrthographicMatrix(-ratio, ratio, -1.0, 1.0, 0.1, 100.0);
            if (ext_proj_matrix != Eigen::Matrix4f::Identity())
                trackballProjectionMatrix = ext_proj_matrix;

            trackball_shader.bind();

            //Using unique viewMatrix for the trackball, considering only the rotation to be visualized.
            Eigen::Affine3f trackballViewMatrix = ext_view_matrix;
            trackballViewMatrix.translate(default_translation);
            trackballViewMatrix.rotate(quaternion);
                        trackballViewMatrix.scale(radius);
            trackball_shader.setUniform("viewMatrix", trackballViewMatrix);
            trackball_shader.setUniform("projectionMatrix", trackballProjectionMatrix);
            trackball_shader.setUniform("nearPlane", near_plane);
            trackball_shader.setUniform("farPlane", far_plane);

            mesh.bindBuffers();

            //X:
            Eigen::Vector4f color_vector(1.0, 0.0, 0.0, 1.0);
            trackball_shader.setUniform("modelMatrix", Eigen::Affine3f::Identity()*Eigen::AngleAxis<float>(M_PI/2.0,Eigen::Vector3f(0.0,1.0,0.0)));
            trackball_shader.setUniform("in_Color", color_vector);
            mesh.renderLineLoop();

            //Y:
            color_vector << 0.0, 1.0, 0.0, 1.0;
            trackball_shader.setUniform("modelMatrix", Eigen::Affine3f::Identity()*Eigen::AngleAxis<float>(M_PI/2.0,Eigen::Vector3f(1.0,0.0,0.0)));
            trackball_shader.setUniform("in_Color", color_vector);
            mesh.renderLineLoop();

            //Z:
            color_vector << 0.0, 0.0, 1.0, 1.0;            
            trackball_shader.setUniform("modelMatrix", Eigen::Affine3f::Identity());
            trackball_shader.setUniform("in_Color", color_vector);
            mesh.renderLineLoop();

            mesh.unbindBuffers();

            trackball_shader.unbind();
        }
    }

};

class DirectionalTrackball : public Tucano::Trackball
{
private:

    Tucano::Shapes::Arrow arrow;

    Eigen::Quaternion<float> quaternion_h;
    Eigen::Quaternion<float> quaternion_v;

protected:


    Eigen::Quaternion<float> computeRotationAngle (float sensibility = 1.0)
    {
        //Given two position vectors, corresponding to the initial and final mouse coordinates, calculate the rotation of the sphere that will keep the mouse always in the initial position.

        if(initialPosition.norm() > 0) {
            initialPosition.normalize();
        }
        if(finalPosition.norm() > 0) {
            finalPosition.normalize();
        }

        Eigen::Vector3f ini;
        Eigen::Vector3f fin;
        float dot, angle;

        ini << initialPosition[0], 0.0, initialPosition[2];
        ini.normalize();
        fin << finalPosition[0], 0.0, finalPosition[2];
        fin.normalize();
        dot = ini.dot(fin);
        angle = (dot <= 1) ? acos(dot) : 0;
        if (initialPosition[0] > finalPosition[0])
            angle *= -1;
        angle *= sensibility;
        Eigen::Quaternion<float> qx (Eigen::AngleAxis<float>(angle, Eigen::Vector3f::UnitY()));

        ini << 0.0, initialPosition[1], initialPosition[2];
        ini.normalize();
        fin << 0.0, finalPosition[1], finalPosition[2];
        fin.normalize();
        dot = ini.dot(fin);
        angle = (dot <= 1) ? acos(dot) : 0;
         if (initialPosition[1] < finalPosition[1])
            angle *= -1;
        angle *= sensibility;
        Eigen::Quaternion<float> qy (Eigen::AngleAxis<float>(angle, Eigen::Vector3f::UnitX()));

        quaternion_h = qx * quaternion_h;
        quaternion_v = qy * quaternion_v;
        quaternion_h.normalize();
        quaternion_v.normalize();

        quaternion = quaternion_h * quaternion_v;
        quaternion.normalize();
        return qx * qy;
    }



public:
 
    DirectionalTrackball (void)
    {
        arrow = Tucano::Shapes::Arrow(0.05, 0.8, 0.12, 0.2);
        arrow.setColor(Eigen::Vector4f(0.8, 0.8, 0.2, 1.0));
        quaternion_h = Eigen::Quaternion<float>::Identity();
        quaternion_v = Eigen::Quaternion<float>::Identity();
    }


        void setRotation (Eigen::Quaternion<float> q)
        {
                quaternion = q;
                updateViewMatrix();
        }

        void renderDirection (Tucano::Camera &ext_camera, bool render_from_ext = false)
        {
            glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
            float ratio = (viewport[2]) / (viewport[3]);
    
        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));

        Tucano::Camera rep_camera;
        rep_camera.setViewMatrix(rep_view_matrix);
        rep_camera.viewMatrix()->rotate( ext_camera.getViewMatrix().rotation() );
        rep_camera.setProjectionMatrix(rep_projection_matrix);
        rep_camera.setViewport(ext_camera.getViewport());
        
        Tucano::Camera lightcam;
        lightcam.viewMatrix()->translate(Eigen::Vector3f(0.0, 0.0, -3.0));

                arrow.resetModelMatrix();
        arrow.modelMatrix()->rotate(quaternion);
        if (render_from_ext)
        {
            arrow.modelMatrix()->translate(default_translation);
                    arrow.modelMatrix()->scale(0.3);
        }
        else
        {
            arrow.modelMatrix()->scale(0.12);
        }
        arrow.modelMatrix()->rotate ( Eigen::AngleAxis<float>(M_PI, Eigen::Vector3f::UnitY()));
        arrow.normalizeModelMatrix();

        if (render_from_ext)
            arrow.render(ext_camera, lightcam);
        else
                arrow.render(rep_camera, lightcam);

        }

   
    void updateViewMatrix (void)
    {
        resetViewMatrix();
        rotate(quaternion);
        translate(default_translation);
    }


};

class Manipulator : public Tucano::Trackball {

protected:

    Tucano::Camera *external_camera;

    Eigen::Vector3f sphere_position = Eigen::Vector3f::Zero();

public:
    Manipulator (void)
    {
        external_camera = 0;
        default_translation = Eigen::Vector3f::Zero();
    }

    Eigen::Vector3f getSpherePos (void)
    {
        return sphere_position;
    }

        void setSpherePos (const Eigen::Vector3f& pos)
        {
                sphere_position = pos;
        }


    void setExternalCamera (Tucano::Camera *ext_cam)
    {
        external_camera = ext_cam;
        viewport = external_camera->getViewport();
    }

};

class TranslationManipulator : public Tucano::Manipulator
{

protected:


public:

    Eigen::Vector3f computeTranslationVector (void)
    {
        //Eigen::Vector2f translationFactor = finalTranslationPosition - initialTranslationPosition;
        Eigen::Vector3f sphere_center = (view_matrix * Eigen::Vector4f(0.0, 0.0, 0.0, 1.0)).head(3);
        sphere_center = translationVector;
        Eigen::Vector3f ray_origin = external_camera->getCenter();

        Eigen::Vector3f ray_direction = Tucano::Math::rayDirection(finalTranslationPosition, external_camera->getViewportSize(), external_camera->getProjectionMatrix(), external_camera->getViewMatrix());

        //Eigen::Vector3f normal = (sphere_center - ray_origin).normalized();
        Eigen::Vector3f normal = external_camera->getViewMatrix().rotation().inverse()*Eigen::Vector3f::UnitZ();

        Eigen::Vector3f inc = Eigen::Vector3f::Zero();
        if (Tucano::Math::rayPlaneIntersection(ray_direction, ray_origin, sphere_center, normal, sphere_position))
        {
            inc = sphere_position - sphere_center;
            translationVector += inc;
        }
        return inc;

        //translationVector += external_camera->getViewMatrix().rotation().inverse()*Eigen::Vector3f(translationFactor[0],translationFactor[1], 0.0);
    }

    Eigen::Vector3f translateCamera (const Eigen::Vector2f& pos)
    {
        Eigen::Vector3f increment = Eigen::Vector3f::Zero();


        if (!translating)
        {
            translating = true;
            initialTranslationPosition = pos;
        }
        else if (pos != initialPosition.head(2))
        {
            finalTranslationPosition = pos;
            increment = computeTranslationVector();
            updateViewMatrix();
            initialTranslationPosition = finalTranslationPosition;
        }
        return increment;
    }

    void updateViewMatrix (void)
    {
        if (!external_camera)
            return;

        resetViewMatrix();
        translate(default_translation);
        translate(translationVector);
        scale(radius);
    }

};

class RotationManipulator : public Tucano::Manipulator {

private:


    Eigen::Vector3f last_position = Eigen::Vector3f::Zero();

    Eigen::Vector3f sphere_position = Eigen::Vector3f::Zero();

    float inner_radius = 1.0;
    
    float outer_radius = 1.3;

    int selected_axis = -1;

    Eigen::Vector3f selected_normal = Eigen::Vector3f::Zero();

protected:

    bool computeSphere3DPosition (const Eigen::Vector2f& pixel, Eigen::Vector3f& sphere_pos)
    {
        Eigen::Vector3f ray_direction = Tucano::Math::rayDirection(pixel, external_camera->getViewportSize(), external_camera->getProjectionMatrix(), external_camera->getViewMatrix());
        Eigen::Vector3f sphere_center = (view_matrix * Eigen::Vector4f(0.0, 0.0, 0.0, 1.0)).head(3);
        Eigen::Vector3f ray_origin = external_camera->getCenter();
        if (Tucano::Math::raySphereIntersection(ray_direction, ray_origin, sphere_center, radius, sphere_pos))
        {
            sphere_pos = sphere_pos - sphere_center;
            return true;
        }
        else if (rotating)
        {
            Eigen::Vector3f normal = (sphere_center - ray_origin).normalized();
            if (Tucano::Math::rayPlaneIntersection(ray_direction, ray_origin, sphere_center, normal, sphere_pos))
            {
                sphere_pos = (sphere_pos - sphere_center).normalized() * radius;
                return true;
            }

        }
        return false; 
    }

    bool computeRing3DPosition (const Eigen::Vector2f& pixel, Eigen::Vector3f& sphere_pos)
    {
        Eigen::Vector3f ray_direction = Tucano::Math::rayDirection(pixel, external_camera->getViewportSize(), external_camera->getProjectionMatrix(), external_camera->getViewMatrix());
        Eigen::Vector3f sphere_center = (view_matrix * Eigen::Vector4f(0.0, 0.0, 0.0, 1.0)).head(3);
        Eigen::Matrix3f normal_matrix = view_matrix.linear().inverse().transpose();
        Eigen::Vector3f ray_origin = external_camera->getCenter();

        if (selected_axis == -1)
        {
            if (Tucano::Math::rayRingIntersection(ray_direction, ray_origin, sphere_center, normal_matrix * Eigen::Vector3f::UnitX(), inner_radius, outer_radius, sphere_pos))
            {
                selected_axis = 0;
                selected_normal = Eigen::Vector3f::UnitX();
                sphere_pos = sphere_pos - sphere_center;
                return true;
            }
            if (Tucano::Math::rayRingIntersection(ray_direction, ray_origin, sphere_center, normal_matrix * Eigen::Vector3f::UnitY(), inner_radius, outer_radius, sphere_pos))
            {
                selected_axis = 1;
                selected_normal = Eigen::Vector3f::UnitY();
                sphere_pos = sphere_pos - sphere_center;
                return true;
            }
            if (Tucano::Math::rayRingIntersection(ray_direction, ray_origin, sphere_center, normal_matrix * Eigen::Vector3f::UnitZ(), inner_radius, outer_radius, sphere_pos))
            {
                selected_axis = 2;
                selected_normal = Eigen::Vector3f::UnitZ();
                sphere_pos = sphere_pos - sphere_center;
                return true;
            }
        }
        else
        {
            Tucano::Math::rayPlaneIntersection(ray_direction, ray_origin, sphere_center, view_matrix.linear().inverse().transpose()* selected_normal, sphere_pos);
            sphere_pos = sphere_pos - sphere_center;
            return true;
        }
        
        return false;
    }


public:

    RotationManipulator (void)
    {
        external_camera = 0;
        default_translation = Eigen::Vector3f::Zero();
        radius = 1.0;
        inner_radius = radius * 1.3;
        outer_radius = radius * 1.5;
    }

    virtual void setRadius (float r)
    {
        radius = r;
        inner_radius = radius * 0.9;
        outer_radius = radius * 1.1;
    }

    Eigen::Quaternion<float> rotateCamera (const Eigen::Vector2f& screen_pos)
    {
        Eigen::Quaternion<float> increment = Eigen::Quaternion<float>::Identity();

        if (computeSphere3DPosition(screen_pos, sphere_position))
        {
            if (!rotating)
            {
                rotating = true;
                initialPosition = sphere_position;
                last_position = sphere_position;
            }
            else if ( screen_pos != initialPosition.head(2))
            {
                //Eigen::Affine3f mat = external_camera->getViewMatrix();
                //float sensibility = 1.0/mat.linear().col(0).norm();
                finalPosition = sphere_position;
                //increment = computeRotationAngle(sensibility);
                increment = computeRotationAngle(1.0);
                updateViewMatrix();
                initialPosition = finalPosition;
            }
        }
        return increment;
    }

    Eigen::Quaternion<float> computeRotationAngle (float sensibility = 1.0)
    {
        //Given two position vectors, corresponding to the initial and final mouse coordinates, calculate the rotation of the sphere that will keep the mouse always in the initial position.

        if(initialPosition.norm() > 0) {
            initialPosition.normalize();
        }
        if(finalPosition.norm() > 0) {
            finalPosition.normalize();
        }

        Eigen::Vector3f rotationAxis = initialPosition.cross(finalPosition);

        if(rotationAxis.norm() != 0) {
            rotationAxis.normalize();
        }

        float dot = initialPosition.dot(finalPosition);

        float rotationAngle = (dot <= 1) ? acos(dot) : 0;//If, by losing floating point precision, the dot product between the initial and final positions is bigger than one, ignore the rotation.
        Eigen::Quaternion<float> q (Eigen::AngleAxis<float>(rotationAngle,rotationAxis));
        return q;
    }


    virtual Eigen::Vector3f computeTranslationVector (void)
    {
        Eigen::Vector2f translationFactor = finalTranslationPosition - initialTranslationPosition;
        Eigen::Vector3f inc = external_camera->getViewMatrix().rotation().inverse()*Eigen::Vector3f(translationFactor[0],translationFactor[1], 0.0);
        translationVector += inc;
       return inc; 
    }

 
    void updateViewMatrix (void)
    {
        if (!external_camera)
            return;

        resetViewMatrix();
        translate(default_translation);
        translate(translationVector);
        rotate(quaternion);
        rotate(default_quaternion);
        scale(radius);
    }

    void endRotation (void)
    {
        rotating = false;
        selected_axis = -1;
    }

    void render (void)
    {
        if(drawTrackball && external_camera)
        {
            viewport = external_camera->getViewport();

            glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);

            trackballProjectionMatrix = external_camera->getProjectionMatrix();

            trackball_shader.bind();

            Eigen::Affine3f trackballViewMatrix = external_camera->getViewMatrix() * view_matrix;

            trackball_shader.setUniform("viewMatrix", trackballViewMatrix);
            trackball_shader.setUniform("projectionMatrix", trackballProjectionMatrix);
            trackball_shader.setUniform("nearPlane", near_plane);
            trackball_shader.setUniform("farPlane", far_plane);

            mesh.bindBuffers();

            //X:
            Eigen::Vector4f color_vector;
                
            color_vector << 0.8, 0.4, 0.4, 1.0;
            trackball_shader.setUniform("modelMatrix", Eigen::Affine3f::Identity()*Eigen::AngleAxis<float>(M_PI/2.0,Eigen::Vector3f(0.0,1.0,0.0)));
            trackball_shader.setUniform("in_Color", color_vector);
            mesh.renderLineLoop();

            //Y:
            color_vector << 0.0, 1.0, 0.0, 1.0;
            trackball_shader.setUniform("modelMatrix", Eigen::Affine3f::Identity()*Eigen::AngleAxis<float>(M_PI/2.0,Eigen::Vector3f(1.0,0.0,0.0)));
            trackball_shader.setUniform("in_Color", color_vector);
            mesh.renderLineLoop();

            //Z:
            color_vector << 0.0, 0.0, 1.0, 1.0;            
            trackball_shader.setUniform("modelMatrix", Eigen::Affine3f::Identity());
            trackball_shader.setUniform("in_Color", color_vector);
            mesh.renderLineLoop();

            mesh.unbindBuffers();

            trackball_shader.unbind();
        }
    }
};


}
#endif