gui_trackball.h

Go to the documentation of this file.

/* $Id: gui_trackball.h 18278 2014-11-25 01:42:10Z ksimek $ */
/* {{{=========================================================================== *
   |
   |  Copyright (c) 1994-2011 by Kobus Barnard (author)
   |
   |  Personal and educational use of this code is granted, provided that this
   |  header is kept intact, and that the authorship is not misrepresented, that
   |  its use is acknowledged in publications, and relevant papers are cited.
   |
   |  For other use contact the author (kobus AT cs DOT arizona DOT edu).
   |
   |  Please note that the code in this file has not necessarily been adequately
   |  tested. Naturally, there is no guarantee of performance, support, or fitness
   |  for any particular task. Nonetheless, I am interested in hearing about
   |  problems that you encounter.
   |
   |  Author:  Kyle Simek
 * =========================================================================== }}}*/

// vim: tabstop=4 shiftwidth=4 foldmethod=marker

#ifndef KJB_CPP_GUI_TRACKBALL_H
#define KJB_CPP_GUI_TRACKBALL_H

#ifdef KJB_HAVE_OPENGL
#include <m_cpp/m_vector.h>
#include <m_cpp/m_vector_d.h>
#include <g_cpp/g_quaternion.h>
#include <gr_cpp/gr_primitive.h>
#include <gr_cpp/gr_opengl.h>
#include <camera_cpp/perspective_camera.h>

#ifdef KJB_HAVE_GLUT
#include <gr_cpp/gr_glut.h>
#endif

#include <boost/bind.hpp>

namespace kjb
{
namespace gui
{

// forward declaration
class Viewer;

class Trackball
{
    enum Mouse_mode {no_mode, rotate_mode, zoom_mode, slide_mode} ;
public:
    Trackball(double diameter = 0.7, double x = 0.5, double y = 0.5) :
        sphere_center_(x,y),
        sphere_radius_(diameter / 2.0),
        click_pt_(), // size = 0 is intentional
        drag_pt_(3),
        cur_q_(),
        delta_q_(),
        cur_mouse_x_(),
        cur_mouse_y_(),
        cur_t_(kjb::Vector(0, 0, -10)),
        xy_scale_(1.0),
        mode_(no_mode),
        offset_x_(0),
        offset_y_(0),
        width_(1),
        height_(1),
        base_cam_(1.0, 1000.0),
        cam_(base_cam_),
        cam_dirty_(false),
        fixed_fovy_(DEFAULT_FOVY * M_PI/180),
        object_origin_(0.0, 0.0, 0.0),
        ACCELERATION_FACTOR(1.0/200.0)
    {

        base_cam_.set_world_origin(kjb::Vector(cur_t_.begin(), cur_t_.end()));
        cam_ = base_cam_;

        set_focal_from_fovy_();
    }

#ifdef KJB_HAVE_GLUT
    void bind(kjb::opengl::Glut_window& wnd)
    {
        using namespace boost;

        wnd.set_mouse_callback(boost::bind(&Trackball::glut_mouse_down, this, _1, _2, _3, _4));
        wnd.set_motion_callback(boost::bind(&Trackball::glut_mouse_move, this, _1, _2));

        update_viewport();
    }
#endif

    void attach(Viewer& wnd);

    void update_viewport();

    void update_viewport(int x, int y, int width, int height);

    bool glut_mouse_down(int button, int state, int x, int y)
    {
        return opengl_mouse_down(button, state, x, height_ - y - 1);
    }

    bool opengl_mouse_down(int button, int state, int x, int y);

    void rotate_mouse_down(double x, double y);

    bool glut_mouse_move(int x, int y)
    {
        return opengl_mouse_move(x, height_ - y - 1);
    }

    bool opengl_mouse_move(int x, int y);

    void zoom_mouse_move(int x, int y);

    void slide_mouse_move(int x, int y);

    void translate_mouse_down(int x, int y);

    void rotate_mouse_move(double x, double y);

    // Call when dragging is done
    void rotate_mouse_up();

    const Quaternion get_orientation()
    {
        update_camera_();
        return cam_.get_orientation();
    }

    void set_extrinsic(const kjb::Matrix& extrinsic)
    {
        set_extrinsic_dispatch_(extrinsic);
    }

    void set_extrinsic(const kjb::Matrix4& extrinsic)
    {
        set_extrinsic_dispatch_(extrinsic);
    }

    template <class Matrix_type>
    void set_extrinsic_dispatch_(const Matrix_type& extrinsic);

    void set_clipping_planes(double near, double far);

    void set_camera(const Perspective_camera& cam);

    void set_camera(const Perspective_camera& cam, double height);

    void set_camera_same_fovy(const Perspective_camera& cam);

    const kjb::Perspective_camera& get_camera() const;

    void set_object_origin(const Vector3& o);

    const Vector3& get_object_origin() const;

    void reset();

    inline void prepare_for_rendering()
    {
        return prepare_for_rendering_dispatch_(false, 0, 0, 0, 0);
    }

    inline void prepare_for_picking(double x, double y, double width, double height)
    {
        return prepare_for_rendering_dispatch_(
                true, x, y, width, height);
    }

    void prepare_for_rendering_dispatch_(bool selecting, double select_x, double select_y, double select_dx, double select_dy );

    void render_object_origin();

//    /// manually set the trackball orientation
//    // unclear how to handle non-zero object origin; disabling for now
//    void set_orientation(const Quaternion& q)
//    {
//        // make sure mouse isn't down
//        assert(click_pt_.size() == 0);
//
//        delta_q_.reset_identity();
//        cur_q_.reset_identity();
//
//        base_cam_.set_orientation(q);
//        cam_.set_orientation(q);
//    }

    void render();

    // returns what the trackball thinks the viewport height is
    int viewport_width() 
    {
        return width_;
    }

    // returns what the trackball thinks the viewport height is
    int viewport_height() 
    {
        return height_;
    }

    // returns what the trackball thinks the viewport x_offset is
    int viewport_x_offset()
    {
        return offset_x_;
    }

    // returns what the trackball thinks the viewport y_offset is
    int viewport_y_offset()
    {
        return offset_x_;
    }
private:
    // returns the focal length in pixels
    double get_focal_length_() const
    {
        return cam_.get_focal_length();
    }

    double get_xy_scale_() const
    {
        // z is always negative (origin is always in front of us)
        // so we negate it here.
        return -(cur_t_[2]) / get_focal_length_();
    }


    double get_z(double x, double y);

private:
    void update_camera_() const;


    double get_fovy_from_focal_(double focal_length, double image_height);

    void set_focal_from_fovy_();
private:
//    double near_;
//    double far_;
    
    Vector sphere_center_;
    double sphere_radius_;

    Vector click_pt_;
    Vector drag_pt_;

    Quaternion cur_q_;
    Quaternion delta_q_;

    int cur_mouse_x_;
    int cur_mouse_y_;

    kjb::Vector3 cur_t_;
    double xy_scale_;

    Mouse_mode mode_;

    int offset_x_;
    int offset_y_;
    int width_;
    int height_;

    kjb::Perspective_camera base_cam_;
    mutable kjb::Perspective_camera cam_;
    mutable bool cam_dirty_;

    double fixed_fovy_;
    Vector3 object_origin_;

    const double ACCELERATION_FACTOR;
    static const float DEFAULT_FOVY;
};
} // namespace gui
} // namespace kjb

#endif /* HAVE_OPENGL */
#endif