MyGlutMouseHandler.h

Go to the documentation of this file.

#ifndef NAN_INCLUDED_MyGlutMouseHandler_h
#define NAN_INCLUDED_MyGlutMouseHandler_h

#include "../common/GlutMouseManager.h"
#include <GL/glut.h>
#include "IK_solver.h"

class MyGlutMouseHandler : public GlutMouseHandler
{
 
public :
 
    static 
        MyGlutMouseHandler *
    New(
    ) {
        MEM_SmartPtr<MyGlutMouseHandler> output = new MyGlutMouseHandler();
        if (output == NULL
        ) {
            return NULL;
        }
        return output.Release();
        
    }

        void
    SetChain(
        IK_Chain_ExternPtr *chains, int num_chains
    ){
        m_chains = chains;
        m_num_chains = num_chains;
    }

        void
    Mouse(
        int button,
        int state,
        int x,
        int y
    ){
        if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) {
            m_moving = true;
            m_begin_x = x;
            m_begin_y = y;  
        }
        if (button == GLUT_LEFT_BUTTON && state == GLUT_UP) {
            m_moving = false;
        }

        if (button == GLUT_RIGHT_BUTTON && state == GLUT_DOWN) {
            m_tracking = true;
        }
        if (button == GLUT_RIGHT_BUTTON && state == GLUT_UP) {
            m_tracking = false;
        }

        if (button == GLUT_MIDDLE_BUTTON && state == GLUT_DOWN) {
            m_cg_on = true;
        }
        if (button == GLUT_MIDDLE_BUTTON && state == GLUT_UP) {
            m_cg_on = false;
        }

    }


        void
    Motion(
        int x,
        int y
    ){
        if (m_moving) {
            m_angle_x = m_angle_x + (x - m_begin_x);
            m_begin_x = x;

            m_angle_y = m_angle_y + (y - m_begin_y);
            m_begin_y = y;

            glutPostRedisplay();
        }
        if (m_tracking) {

            int w_h = glutGet((GLenum)GLUT_WINDOW_HEIGHT);

            y = w_h - y;

            double mvmatrix[16];
            double projmatrix[16];
            GLint viewport[4];

            double px, py, pz,sz;

            /* Get the matrices needed for gluUnProject */
            glGetIntegerv(GL_VIEWPORT, viewport);
            glGetDoublev(GL_MODELVIEW_MATRIX, mvmatrix);
            glGetDoublev(GL_PROJECTION_MATRIX, projmatrix);

            // work out the position of the end effector in screen space

            GLdouble ex,ey,ez;
            ex = m_pos.x();
            ey = m_pos.y();
            ez = m_pos.z();

            gluProject(ex, ey, ez, mvmatrix, projmatrix, viewport, &px, &py, &sz);
            gluUnProject((GLdouble) x, (GLdouble) y, sz, mvmatrix, projmatrix, viewport, &px, &py, &pz);

            m_pos = MT_Vector3(px,py,pz);

        }
        if (m_tracking || m_cg_on) {
            float temp[3];
            m_pos.getValue(temp);

            IK_SolveChain(m_chains[0],temp,0.01,200,0.1,m_chains[1]->segments);
            IK_LoadChain(m_chains[0],m_chains[0]->segments,m_chains[0]->num_segments);
    
            glutPostRedisplay();
        }           


    }

    const 
        float
    AngleX(
    ) const {
        return m_angle_x;
    }

    const 
        float
    AngleY(
    ) const {
        return m_angle_y;
    }

    const
        MT_Vector3  
    Position(
    ) const {
        return m_pos;
    }


private :

    MyGlutMouseHandler (
    ) :  
        m_angle_x(0),
        m_angle_y(0),
        m_begin_x(0),
        m_begin_y(0),
        m_moving (false),
        m_tracking (false),
        m_pos(0,0,0),
        m_cg_on (false),
        m_chains(NULL),
        m_num_chains(0)
    {
    };
        
    float m_angle_x;
    float m_angle_y;
    float m_begin_x;
    float m_begin_y;

    bool m_moving;
    bool m_tracking;
    bool m_cg_on;
    MT_Vector3 m_pos;
    
    IK_Chain_ExternPtr *m_chains;
    int m_num_chains;

};

#endif