camera.hpp

Go to the documentation of this file.

#ifndef __CAMERA__
#define __CAMERA__

#include <tucano/shader.hpp>
#include <Eigen/Dense>
#include <cmath>

namespace Tucano
{

class Camera {

protected:

    Eigen::Matrix4f projection_matrix;

    Eigen::Affine3f view_matrix;

    Eigen::Vector4f viewport;

    // A default view matrix for reseting view
    Eigen::Affine3f default_view;

    float near_plane;

    float far_plane;

    float frustum_left;

    float frustum_right;

    float frustum_top;

    float frustum_bottom;

    float aspect_ratio;

    float focal_length;

    float fovy;

    bool use_perspective;

public:

    void resetViewMatrix (void)
    {
        view_matrix = default_view;
    }

    void resetProjectionMatrix (void)
    {
        projection_matrix = Eigen::Matrix4f::Identity();
    }

    void reset (void)
    {
        resetViewMatrix();
        resetProjectionMatrix();
    }


    Eigen::Vector3f getCenter (void) const
    {
        return view_matrix.linear().inverse() * (-view_matrix.translation());
    }

    void getViewMatrix (GLdouble *matrix)
    {
        Eigen::Matrix4f mv = view_matrix.matrix();
        for (int i = 0; i < 16; ++i)
        {
            matrix[i] = mv(i);
        }
    }


    void getProjectionMatrix (GLdouble *matrix)
    {
        for (int i = 0; i < 16; ++i)
        {
            matrix[i] = projection_matrix(i);
        }
    }

    inline Eigen::Vector3f projectPoint (const Eigen::Vector4f& pt, Eigen::Vector4f& viewport)
    {
        Eigen::Vector3f screen_pt = Eigen::Vector3f::Zero();
        Eigen::Vector4f proj = projection_matrix * view_matrix * pt;
        if (proj[3] == 0.0)
            return screen_pt;

        proj /= proj[3];

        screen_pt[0] = viewport[0] + viewport[2] * (proj[0] * 0.5 + 0.5);
        screen_pt[1] = viewport[1] + viewport[3] * (proj[1] * 0.5 + 0.5);
        screen_pt[2] = proj[2]*0.5 + 0.5;
        return screen_pt;
    }


    Eigen::Affine3f getViewMatrix (void) const
    {
        return view_matrix;
    }

         Eigen::Affine3f* viewMatrix (void)
        {
                return &view_matrix;
        }

    Eigen::Matrix4f getProjectionMatrix (void) const
    {
        return projection_matrix;
    }

    Eigen::Matrix4f* projectionMatrix (void) 
    {
        return &projection_matrix;
    }


    Eigen::Matrix3f getRotationMatrix (void) const
    {
        return view_matrix.rotation();
    }


    Eigen::Vector3f getTranslationMatrix (void) const
    {
        return view_matrix.translation();
    }    

    float getPerspectiveScale (void) const
    {
        return (float)1.0f/tan((fovy/2.0f)*(M_PI/180.0f));
    }

    Eigen::Vector4f getViewport (void) const
    {
        return viewport;
    }

    Eigen::Vector2i getViewportSize (void) const
    {
        return Eigen::Vector2i(viewport[2], viewport[3]);
    }

        float getViewportAspectRatio (void) const
        {
                return (viewport[2] / viewport[3]);
        }

    void setViewport (const Eigen::Vector4f &vp)
    {
        viewport = vp;
    }

    void setViewport (const Eigen::Vector2i &vp)
    {
        viewport = Eigen::Vector4f(0.0, 0.0, (float)vp[0], (float)vp[1]);
    }


    void setViewport (const Eigen::Vector2f &vp)
    {
        viewport = Eigen::Vector4f(0.0, 0.0, vp[0], vp[1]);
    }

    void setProjectionMatrix(const Eigen::Matrix4f& mat)
    {
        projection_matrix = mat;
    }

    void setViewMatrix(const Eigen::Affine3f& mat)
    {
        view_matrix = mat;
    }


    float getNearPlane (void) const
    {
        return near_plane;
    }

    float getFarPlane (void) const
    {
        return far_plane;
    }

    ~Camera()
    {
    }

    float getFovy (void) const
    {
        return fovy;
    }

public:

    Camera (void)
    {
        frustum_left = -1.0;
        frustum_right = 1.0;
        frustum_bottom = -1.0;
        frustum_top = -1.0;
        near_plane = 0.1;
        far_plane = 100.0;
        fovy = 60.0;

        default_view = Eigen::Affine3f::Identity();
        reset();
    }


    static Eigen::Matrix4f createPerspectiveMatrix (float fy, float in_aspect_ratio, float in_near_plane,float in_far_plane)
    {
        Eigen::Matrix4f out = Eigen::Matrix4f::Zero();

        const float
                y_scale = (float)1.0/tan((fy/2.0)*(M_PI/180.0)),
                x_scale = y_scale / in_aspect_ratio,
                frustum_length = in_far_plane - in_near_plane;

        out(0,0) = x_scale;
        out(1,1) = y_scale;
        out(2,2) = -((in_far_plane + in_near_plane) / frustum_length);
        out(3,2) = -1.0;
        out(2,3) = -((2 * in_near_plane * in_far_plane) / frustum_length);

        return out;
    }

    Eigen::Matrix4f setPerspectiveMatrix (float fy, float in_aspect_ratio, float in_near_plane,float in_far_plane)
    {
        fovy = fy;
        aspect_ratio = in_aspect_ratio;
        near_plane = in_near_plane;
        far_plane = in_far_plane;

        Eigen::Matrix4f proj = createPerspectiveMatrix(fovy, aspect_ratio, near_plane, far_plane);
        setProjectionMatrix(proj);
        use_perspective = true;
        return proj;
    }

    void changeFovy (float new_fovy)
    {
        fovy = new_fovy;
        setPerspectiveMatrix(fovy, aspect_ratio, near_plane, far_plane);
    }

    static Eigen::Matrix4f createOrthographicMatrix (float left, float right, float bottom, float top, float near_plane, float far_plane)
    {
        Eigen::Matrix4f out = Eigen::Matrix4f::Zero();

        out(0,0) = 2.0/(right-left);
        out(1,1) = 2.0/(top-bottom);
        out(2,2) = -2.0/(far_plane-near_plane);
        out(3,3) = 1.0;
        out(0,3) = -(right+left)/(right-left);
        out(1,3) = -(top+bottom)/(top-bottom);
        out(2,3) = -(far_plane+near_plane)/(far_plane-near_plane);

        return out;
    }

    Eigen::Matrix4f setOrthographicMatrix (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);
        setProjectionMatrix(proj);
        use_perspective = false;
        return proj;
    }

    void incrementFov (float inc)
    {
        if (use_perspective)
        {
            changeFovy(fovy + inc);
        }
    }

    void translate (const Eigen::Vector3f& translation)
    {
        view_matrix.translate(translation);
    }

    void rotate (const Eigen::Quaternion<float>& rotation)
    {
        view_matrix.rotate(rotation);
    }

    void scale (const Eigen::Vector3f& scale_factors)
    {
        view_matrix.scale(scale_factors);
    }

    void scale (float scale_factor)
    {
        view_matrix.scale(scale_factor);
    }
};

}
#endif