vcglib: trackball.cpp Source File

00001 /****************************************************************************
00002 * VCGLib                                                            o o     *
00003 * Visual and Computer Graphics Library                            o     o   *
00004 *                                                                _   O  _   *
00005 * Copyright(C) 2004                                                \/)\/    *
00006 * Visual Computing Lab                                            /\/|      *
00007 * ISTI - Italian National Research Council                           |      *
00008 *                                                                    \      *
00009 * All rights reserved.                                                      *
00010 *                                                                           *
00011 * This program is free software; you can redistribute it and/or modify      *
00012 * it under the terms of the GNU General Public License as published by      *
00013 * the Free Software Foundation; either version 2 of the License, or         *
00014 * (at your option) any later version.                                       *
00015 *                                                                           *
00016 * This program is distributed in the hope that it will be useful,           *
00017 * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
00018 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
00019 * GNU General Public License (http://www.gnu.org/licenses/gpl.txt)          *
00020 * for more details.                                                         *
00021 *                                                                           *
00022 ****************************************************************************/
00023 /****************************************************************************
00024   History
00025 
00026 $Log: not supported by cvs2svn $
00027 Revision 1.26  2008/02/24 14:37:00  ponchio
00028 Restored trackball functionality. Not very much tested, and code will need some
00029 cleanup.
00030 
00031 Revision 1.25  2008/02/22 18:57:46  benedetti
00032 first attempt to correct after quaternion ToMatrix() inversion (does not work yet)
00033 
00034 Revision 1.24  2007/12/21 12:29:34  tarini
00035 *** empty log message ***
00036 
00037 Revision 1.23  2007/10/12 14:02:39  corsini
00038 solve memory leak in dtor
00039 
00040 Revision 1.22  2007/07/09 22:47:18  benedetti
00041 Removed using namespace std and modified accordingly.
00042 
00043 Revision 1.21  2007/06/20 12:59:43  corsini
00044 adjust wheel back-compatibility
00045 
00046 Revision 1.20  2007/06/13 17:15:08  benedetti
00047 Added one-level undo system and sticky trackmodes.
00048 
00049 Revision 1.19  2007/05/15 15:00:27  benedetti
00050 Moved the drawing code to trackmodes, some other minor changes
00051 
00052 Revision 1.18  2007/02/26 01:30:02  cignoni
00053 Added reflection Name
00054 
00055 Revision 1.17  2007/01/15 15:04:15  tarini
00056 added "ToAscii" and "SetFromAscii" methods to load/store current trackball status from/to ascii strings
00057 (intended uses: clipboard operations and comments inside png snapshots!)
00058 
00059 Revision 1.16  2006/07/26 13:54:45  cignoni
00060 Reversed the direction of wheel scaling and added middle mouse panning
00061 
00062 Revision 1.15  2006/02/13 13:15:52  cignoni
00063 Added Scale and Translate methods.
00064 Added many drawing hints and raised the default num. of steps when drawing circles.
00065 Added MouseDown without coords (for remembering changes of keys modifiers)
00066 Added ZMode to the default modes under Alt+left
00067 Added DrawPostApply (to be completed)
00068 
00069 Revision 1.14  2005/10/17 01:29:46  cignoni
00070 Main restructuring. Removed the Draw function and slightly changed the meaning of the trackball itself.
00071 See the notes at the beginning of trackball.h
00072 
00073 Revision 1.13  2005/04/17 17:48:24  ganovelli
00074 modes deallocation commented (quick and dirty solution..to debug)
00075 
00076 Revision 1.12  2004/12/17 10:28:10  ricciodimare
00077 *** empty log message ***
00078 
00079 Revision 1.11  2004/09/28 15:30:12  ponchio
00080 Added a 'else'.
00081 
00082 Revision 1.10  2004/09/09 14:38:52  ponchio
00083 #include <gl... -> #include <GL...
00084 
00085 Revision 1.9  2004/07/11 22:06:55  cignoni
00086 Added scaling by wheel
00087 
00088 Revision 1.8  2004/06/09 14:01:13  cignoni
00089 Heavily restructured. To be completed only rotation works...
00090 
00091 Revision 1.7  2004/05/14 03:15:09  ponchio
00092 Redesigned partial version.
00093 
00094 Revision 1.6  2004/05/12 20:55:18  ponchio
00095 *** empty log message ***
00096 
00097 Revision 1.5  2004/05/07 12:46:08  cignoni
00098 Restructured and adapted in a better way to opengl
00099 
00100 Revision 1.4  2004/04/07 10:54:10  cignoni
00101 Commented out unused parameter names and other minor warning related issues
00102 
00103 Revision 1.3  2004/03/31 15:08:03  ponchio
00104 Fixed current_action initialization.
00105 
00106 Revision 1.2  2004/03/25 14:55:25  ponchio
00107 Adding copyright.
00108 
00109 
00110 ****************************************************************************/
00111 
00112 #include <GL/glew.h>
00113 #include "trackball.h"
00114 #include<set>
00115 
00116 #include <wrap/gl/math.h>
00117 #include <wrap/gl/space.h>
00118 
00119 using namespace vcg;
00120 
00121 Transform::Transform() {
00122   track.SetIdentity();
00123   radius=1.0f;
00124   center=Point3f(0,0,0);
00125 }
00126 
00127 Trackball::Trackball(): current_button(0), current_mode(NULL), inactive_mode(NULL),
00128                         dragging(false), last_time(0), spinnable(true), spinning(false),
00129                         history_size(10), fixedTimestepMode(false) {
00130   setDefaultMapping ();
00131 }
00132 
00133 Trackball::~Trackball()
00134 {
00135         ClearModes();
00136         delete  inactive_mode;
00137 }
00138 
00139 void Trackball::ClearModes()
00140 {
00141         // Note: people ofter maps different keys to the same modes.
00142         // so we should avoid double deletion of these double referenced modes.
00143         std::set<TrackMode *> goodModes;
00144         std::map<int, TrackMode *>::iterator it;
00145   for(it = modes.begin(); it != modes.end(); it++)
00146                 if ((*it).second) goodModes.insert( (*it).second);
00147 
00148         std::set<TrackMode *>::iterator its;
00149         for(its = goodModes.begin(); its != goodModes.end(); its++)
00150                         delete *its;
00151 
00152         modes.clear();
00153 }
00154 
00155 void Trackball::setDefaultMapping () {
00156   idle_and_keys_mode = NULL;
00157 
00158   inactive_mode = new InactiveMode ();
00159         ClearModes();
00160   modes[0] = NULL;
00161 
00162   modes[BUTTON_MIDDLE | KEY_ALT] =
00163   modes[BUTTON_LEFT] = new SphereMode ();
00164 
00165   modes[BUTTON_LEFT | KEY_CTRL] = new PanMode ();
00166 
00167   modes[BUTTON_MIDDLE] = new PanMode ();
00168 
00169   modes[WHEEL] =
00170   modes[BUTTON_LEFT | KEY_SHIFT] = new ScaleMode ();
00171 
00172   modes[BUTTON_LEFT | KEY_ALT] = new ZMode ();
00173 
00174 }
00175 
00176 void Trackball::SetIdentity() {
00177   track.SetIdentity();
00178   Reset();
00179 }
00180 void Trackball::SetPosition(const Point3f &c, int /* millisec */) {
00181   center = c;
00182 }
00183 
00184 void Trackball::GetView() {
00185   camera.GetView();
00186 }
00187 
00188 // the drawing code has been moved to the trackmodes
00189 void Trackball::DrawPostApply() {
00190         if(current_mode !=NULL){
00191                 current_mode->Draw(this);
00192         }else{
00193                 if (inactive_mode != NULL) inactive_mode->Draw(this);
00194   }
00195 }
00196 
00197 void Trackball::Apply () {
00198   glTranslate (center);
00199   glMultMatrix (track.Matrix());
00200   glTranslate (-center);
00201 }
00202 
00203 void Trackball::Apply(bool ToDraw) {
00204   Apply();
00205   if(ToDraw){
00206     DrawPostApply();
00207   }
00208 }
00209 
00210 
00211 void Trackball::ApplyInverse() {
00212   glTranslate(center);
00213   glMultMatrix(track.InverseMatrix());
00214   glTranslate(-center);
00215 }
00216 
00217 // T(c) S R T(t) T(-c) => S R T(S^(-1) R^(-1)(c) + t - c)
00218 Matrix44f Trackball::Matrix() const{
00219   #ifndef VCG_USE_EIGEN
00220   Matrix44f r; track.rot.ToMatrix(r);
00221   Matrix44f sr    = Matrix44f().SetScale(track.sca, track.sca, track.sca) * r;
00222   Matrix44f s_inv = Matrix44f().SetScale(1/track.sca, 1/track.sca, 1/track.sca);
00223   Matrix44f t     = Matrix44f().SetTranslate(s_inv*r.transpose()*center + track.tra - center);
00224 
00225   return Matrix44f(sr*t);
00226   #else
00227   Eigen::Quaternionf rot(track.rot);
00228   Eigen::Translation3f tr( (1/track.sca) * (rot.inverse() * center) + track.tra - center );
00229   return ( Eigen::Scaling3f(track.sca) * (rot * tr) ).matrix();
00230   #endif
00231 }
00232 
00233 Matrix44f Trackball::InverseMatrix() const{
00234   return Inverse(Matrix());
00235 }
00236 
00237 void Trackball::Scale(const float s)
00238 {
00239   track.sca*=s;
00240 }
00241 
00242 void Trackball::Translate(Point3f tr)
00243 {
00244   Quaternionf irot = track.rot;
00245   irot.Invert();
00246   track.tra = last_track.tra + irot.Rotate(tr)/track.sca;
00247 }
00248 
00249 /***************************************************************/
00250 // DrawCircle () e DrawPlane() have been moved to trackutils.h
00251 // the drawing code has been moved to the trackmodes
00252 /*
00253 void Trackball::DrawCircle() {
00254   int nside=DH.CircleStep;
00255   const double pi2=3.14159265*2.0;
00256   glBegin(GL_LINE_LOOP);
00257   for(double i=0;i<nside;i++){
00258     glNormal3d(cos(i*pi2/nside), sin(i*pi2/nside),  0.0);
00259     glVertex3d(cos(i*pi2/nside), sin(i*pi2/nside),  0.0);
00260   }
00261   glEnd();
00262   DrawPlaneHandle();
00263 }
00264 
00265 void Trackball::DrawPlane() {
00266   const int nl=10;
00267   float w=5.0f/3.0f;
00268   float u;
00269   glBegin(GL_LINES);
00270   glNormal3f(0.0,0.0,1.0);
00271   for( u=-w; u<=w+0.01f; u+=2*w/nl){
00272     glVertex3f(-w,      +u,     0);
00273     glVertex3f(+w,      +u,     0);
00274     glVertex3f(+u,      -w, 0);
00275     glVertex3f(+u,      +w, 0);
00276   }
00277   glEnd();
00278 }
00279 */
00280 
00281 void Trackball::ToAscii(char* result){
00282   float * f = (float*) &track;
00283   sprintf(result, "trackball(%f,%f,%f,%f,%f,%f,%f,%f)",
00284                   f[0],f[1],f[2],f[3],f[4],f[5],f[6],f[7] );
00285 }
00286 
00287 bool Trackball::SetFromAscii(const char * st){
00288   float * f = (float*) &track;
00289   int res=  sscanf(st, "trackball(%f,%f,%f,%f,%f,%f,%f,%f)",
00290                   f+0,f+1,f+2,f+3,f+4,f+5,f+6,f+7 );
00291 
00292   return (res==8);
00293 }
00294 
00295 // DrawPlaneHandle() e DrawIcon() have been moved to trackutils.h
00296 // the drawing code has been moved to the trackmodes
00297 /*
00298 void Trackball::DrawPlaneHandle() {
00299   float r=1.0;
00300   float dr=r/10.0f;
00301   glBegin(GL_LINE_STRIP);
00302   glVertex3f(+r+dr,   +r,   0.0);
00303   glVertex3f(+r   ,   +r+dr,0.0);
00304   glVertex3f(+r-dr,   +r,   0.0);
00305   glVertex3f(+r   ,   +r-dr,0.0);
00306   glVertex3f(+r+dr,   +r,   0.0);
00307   glEnd();
00308   glBegin(GL_LINE_STRIP);
00309   glVertex3f(-r+dr,   -r,   0.0);
00310   glVertex3f(-r   ,   -r+dr,0.0);
00311   glVertex3f(-r-dr,   -r,   0.0);
00312   glVertex3f(-r   ,   -r-dr,0.0);
00313   glVertex3f(-r+dr,   -r,   0.0);
00314   glEnd();
00315 }
00316 
00317 void Trackball::DrawIcon() {
00318   glPushMatrix();
00319 
00320   glScale(radius);
00322   float amb[4] ={.3f,.3f,.3f,1.0f};
00323   float col[4] ={.5f,.5f,.8f,1.0f};
00324   //float col2[4]={.9f,.9f,1.0f,1.0f};
00325   glPushAttrib(GL_ENABLE_BIT | GL_LINE_BIT | GL_CURRENT_BIT | GL_LIGHTING_BIT);
00326 
00327 
00328   if(current_mode == NULL ) glLineWidth(DH.LineWidthStill);
00329                        else glLineWidth(DH.LineWidthMoving);
00330 
00331   glEnable(GL_LIGHTING);
00332   glEnable(GL_LIGHT0);
00333   glEnable(GL_LINE_SMOOTH);
00334   glEnable(GL_BLEND);
00335   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
00336   glColor(DH.color);
00337 
00338   glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,amb);
00339   glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,col);
00340   glPushMatrix();
00341     DrawCircle();
00342     glPushMatrix();
00343 
00344       glRotatef(90,1,0,0);
00345       DrawCircle();
00346       glRotatef(90,0,1,0);
00347       DrawCircle();
00348 
00349     glPopMatrix();
00350   glPopMatrix();
00351 
00352   //glColor4f(1.0,.8f,.8f,1.0f);
00353 
00354   glPopAttrib();
00355 
00356   glPopMatrix();
00357 }
00358 */
00359 
00360 void Trackball::Reset() {
00361   track.SetIdentity();
00362   undo_track = track;
00363   std::map<int, TrackMode *>::iterator i;
00364   for(i = modes.begin(); i != modes.end(); i++){
00365    TrackMode * mode=(*i).second;
00366    if(mode!=NULL)
00367      mode->Reset();
00368   }
00369   if (inactive_mode != NULL) inactive_mode->Reset();
00370  }
00371 
00372 //interface
00373 void Trackball::MouseDown(int button) {
00374   undo_track = track;
00375   current_button |= button;
00376   SetCurrentAction();
00377   Hits.clear();
00378 }
00379 void Trackball::MouseDown(int x, int y, int button) {
00380   undo_track = track;
00381   current_button |= button;
00382   SetCurrentAction();
00383   last_point = Point3f((float)x, (float)y, 0);
00384   Hits.clear();
00385 }
00386 
00387 void Trackball::MouseMove(int x, int y) {
00388   if(current_mode == NULL) return;
00389   if(last_point[2] == -1) { //changed mode in the middle of moving
00390     last_point = Point3f((float)x, (float)y, 0);
00391     return;
00392   }
00393   undo_track = track;
00394   current_mode->Apply(this, Point3f(float(x), float(y), 0));
00395 }
00396 
00397 bool Trackball::IsAnimating(unsigned int msec){
00398         bool res;
00399         if(idle_and_keys_mode == NULL) res=false; else res=idle_and_keys_mode->IsAnimating(this);
00400 
00401         if (!fixedTimestepMode) {
00402         if (msec==0) msec = clock()*1000/CLOCKS_PER_SEC;
00403           if (!res) {
00404           last_time = msec;
00405           }
00406         }
00407         return res;
00408 }
00409 
00410 void Trackball::Sync(unsigned int msec) {
00411         if (!fixedTimestepMode) Animate(msec);
00412 }
00413 
00414 void Trackball::Animate(unsigned int msec){
00415         unsigned int delta;
00416         if (fixedTimestepMode) delta=msec;
00417         else {
00418                 if (msec==0) msec = clock()*1000/CLOCKS_PER_SEC;
00419     delta = msec -last_time;
00420           last_time = msec;
00421         }
00422         if(idle_and_keys_mode == NULL) return;
00423         idle_and_keys_mode->Animate(delta,this);
00424 }
00425 
00426 void Trackball::MouseUp(int /* x */, int /* y */, int button) {
00427   undo_track = track;
00428         ButtonUp(vcg::Trackball::Button(button));
00429   //current_button &= (~button);
00430   //SetCurrentAction();
00431 }
00432 
00433 // it assumes that a notch of 1.0 is a single step of the wheel
00434 void Trackball::MouseWheel(float notch)
00435 {
00436   undo_track = track;
00437         int buttons = current_button;
00438         current_button = WHEEL | (buttons&(KEY_SHIFT|KEY_CTRL|KEY_ALT));
00439         SetCurrentAction();
00440   if (current_mode == NULL)
00441   {
00442     //ScaleMode scalemode;
00443     //scalemode.Apply (this, notch);
00444   }
00445         else
00446         {
00447     current_mode->Apply(this, notch);
00448   }
00449         current_button = buttons;
00450         SetCurrentAction();
00451 }
00452 
00453 void Trackball::MouseWheel(float notch, int button)
00454 {
00455   undo_track = track;
00456   current_button |= button;
00457   SetCurrentAction();
00458   if (current_mode == NULL) {
00459     ScaleMode scalemode;
00460     scalemode.Apply (this, notch);
00461   } else {
00462     current_mode->Apply (this, notch);
00463   }
00464   current_button &= (~button);
00465   SetCurrentAction ();
00466 }
00467 
00468 void Trackball::ButtonDown(Trackball::Button button, unsigned int msec) {
00469         Sync(msec);
00470   bool old_sticky=false, new_sticky=false;
00471   assert (modes.count (0));
00472 
00473         Button b=Button(current_button & MODIFIER_MASK);
00474   if ( ( modes.count (b) ) && ( modes[b] != NULL ) ) old_sticky = modes[b]->isSticky();
00475 
00476   current_button |= button;
00477         b=Button(current_button & MODIFIER_MASK);
00478         if ( ( modes.count (b) ) && ( modes[b] != NULL ) ) new_sticky = modes[b]->isSticky();
00479 
00480   if ( !old_sticky && !new_sticky) SetCurrentAction();
00481 
00482 }
00483 
00484 void Trackball::ButtonUp(Trackball::Button button) {
00485   bool old_sticky=false, new_sticky=false;
00486   assert (modes.count (0));
00487 
00488         Button b=Button(current_button & MODIFIER_MASK);
00489   if ( ( modes.count (b) ) && ( modes[b] != NULL ) ) old_sticky = modes[b]->isSticky();
00490 
00491   current_button &= (~button);
00492         b=Button(current_button & MODIFIER_MASK);
00493         if ( ( modes.count (b) ) && ( modes[b] != NULL ) ) new_sticky = modes[b]->isSticky();
00494 
00495   if ( !old_sticky && !new_sticky) SetCurrentAction();
00496 }
00497 
00498 void Trackball::Undo(){
00499   track = undo_track;
00500   if(current_mode != NULL)
00501     current_mode->Undo();
00502 }
00503 
00504 
00505 //spinning interface
00506 void Trackball::SetSpinnable(bool /* on*/ ){}
00507 bool Trackball::IsSpinnable() {
00508   return spinnable;
00509 }
00510 void Trackball::SetSpinning(Quaternionf &/* spin*/){}
00511 void Trackball::StopSpinning(){}
00512 bool Trackball::IsSpinning() {
00513   return spinning;
00514 }
00515 
00516 //navigation interface:
00517 void Trackball::Back(){}
00518 void Trackball::Forward(){}
00519 void Trackball::Home(){}
00520 void Trackball::HistorySize(int /* length */){}
00521 
00522 void Trackball::SetCurrentAction ()
00523 {
00524   //I use strict matching.
00525   assert (modes.count (0));
00526   if (!modes.count (current_button & MODIFIER_MASK)) {
00527     current_mode = NULL;
00528   } else {
00529     current_mode = modes[current_button & MODIFIER_MASK];
00530     if(current_mode != NULL)
00531       current_mode->SetAction();
00532   }
00533   last_point = Point3f (0, 0, -1);
00534   last_track = track;
00535 }
00536 
00538 //Point3f Trackball::ScreenOrigin() {
00539 //  return camera.Project(ModelOrigin());
00540 //}
00541 
00542 
00543 //return center of trackball in Model coordinates
00544 //Point3f Trackball::ModelOrigin() {
00545 //  return center;
00546 //}
00547 
00548 //Matrix44f Trackball::ScreenToModel() {
00549 //  return camera.inverse;
00550 //}
00551 //
00552 //Similarityf Trackball::ModelToLocal() {
00553 //  Similarityf m = local * last_track;
00554 //  return m;
00555 //}
00556