205ce38ac239c46363d20ab3e052adcf097e19f1
[blender.git] / intern / iksolver / test / ik_glut_test / intern / MyGlutMouseHandler.h
1 /**
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 #ifndef __MYGLUTMOUSEHANDLER_H__
29 #define __MYGLUTMOUSEHANDLER_H__
30
31 #include "../common/GlutMouseManager.h"
32 #include <GL/glut.h>
33 #include "IK_solver.h"
34
35 class MyGlutMouseHandler : public GlutMouseHandler
36 {
37  
38 public :
39  
40         static 
41                 MyGlutMouseHandler *
42         New(
43         ) {
44                 MEM_SmartPtr<MyGlutMouseHandler> output = new MyGlutMouseHandler();
45                 if (output == NULL
46                 ) {
47                         return NULL;
48                 }
49                 return output.Release();
50                 
51         }
52
53                 void
54         SetChain(
55                 IK_Chain_ExternPtr *chains, int num_chains
56         ){
57                 m_chains = chains;
58                 m_num_chains = num_chains;
59         }
60
61                 void
62         Mouse(
63                 int button,
64                 int state,
65                 int x,
66                 int y
67         ){
68                 if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) {
69                         m_moving = true;
70                         m_begin_x = x;
71                         m_begin_y = y;  
72                 }
73                 if (button == GLUT_LEFT_BUTTON && state == GLUT_UP) {
74                         m_moving = false;
75                 }
76
77                 if (button == GLUT_RIGHT_BUTTON && state == GLUT_DOWN) {
78                         m_tracking = true;
79                 }
80                 if (button == GLUT_RIGHT_BUTTON && state == GLUT_UP) {
81                         m_tracking = false;
82                 }
83
84                 if (button == GLUT_MIDDLE_BUTTON && state == GLUT_DOWN) {
85                         m_cg_on = true;
86                 }
87                 if (button == GLUT_MIDDLE_BUTTON && state == GLUT_UP) {
88                         m_cg_on = false;
89                 }
90
91         }
92
93
94                 void
95         Motion(
96                 int x,
97                 int y
98         ){
99                 if (m_moving) {
100                         m_angle_x = m_angle_x + (x - m_begin_x);
101                         m_begin_x = x;
102
103                         m_angle_y = m_angle_y + (y - m_begin_y);
104                         m_begin_y = y;
105
106                         glutPostRedisplay();
107                 }
108                 if (m_tracking) {
109
110                         int w_h = glutGet((GLenum)GLUT_WINDOW_HEIGHT);
111
112                         y = w_h - y;
113
114                         double mvmatrix[16];
115                         double projmatrix[16];
116                         GLint viewport[4];
117
118                         double px, py, pz,sz;
119
120                         /* Get the matrices needed for gluUnProject */
121                         glGetIntegerv(GL_VIEWPORT, viewport);
122                         glGetDoublev(GL_MODELVIEW_MATRIX, mvmatrix);
123                         glGetDoublev(GL_PROJECTION_MATRIX, projmatrix);
124
125                         // work out the position of the end effector in screen space
126
127                         GLdouble ex,ey,ez;
128                         ex = m_pos.x();
129                         ey = m_pos.y();
130                         ez = m_pos.z();
131
132                         gluProject(ex, ey, ez, mvmatrix, projmatrix, viewport, &px, &py, &sz);
133                         gluUnProject((GLdouble) x, (GLdouble) y, sz, mvmatrix, projmatrix, viewport, &px, &py, &pz);
134
135                         m_pos = MT_Vector3(px,py,pz);
136
137                 }
138                 if (m_tracking || m_cg_on) {
139                         float temp[3];
140                         m_pos.getValue(temp);
141
142                         IK_SolveChain(m_chains[0],temp,0.01,200,0.1,m_chains[1]->segments);
143                         IK_LoadChain(m_chains[0],m_chains[0]->segments,m_chains[0]->num_segments);
144         
145                         glutPostRedisplay();
146                 }                       
147
148
149         }
150
151         const 
152                 float
153         AngleX(
154         ) const {
155                 return m_angle_x;
156         }
157
158         const 
159                 float
160         AngleY(
161         ) const {
162                 return m_angle_y;
163         }
164
165         const
166                 MT_Vector3      
167         Position(
168         ) const {
169                 return m_pos;
170         }
171
172
173 private :
174
175         MyGlutMouseHandler (
176         ) :  
177                 m_angle_x(0),
178                 m_angle_y(0),
179                 m_begin_x(0),
180                 m_begin_y(0),
181                 m_moving (false),
182                 m_tracking (false),
183                 m_pos(0,0,0),
184                 m_cg_on (false),
185                 m_chains(NULL),
186                 m_num_chains(0)
187         {
188         };
189                 
190         float m_angle_x;
191         float m_angle_y;
192         float m_begin_x;
193         float m_begin_y;
194
195         bool m_moving;
196         bool m_tracking;
197         bool m_cg_on;
198         MT_Vector3 m_pos;
199         
200         IK_Chain_ExternPtr *m_chains;
201         int m_num_chains;
202
203 };
204
205 #endif
206