trackball.h

Go to the documentation of this file.

/****************************************************************************
* VCGLib                                                            o o     *
* Visual and Computer Graphics Library                            o     o   *
*                                                                _   O  _   *
* Copyright(C) 2004                                               \/)\/     *
* Visual Computing Lab                                            /\/|      *
* ISTI - Italian National Research Council                           |      *
*                                                                    \      *
* All rights reserved.                                                      *
*                                                                           *
* This program is free software; you can redistribute it and/or modify      *
* it under the terms of the GNU General Public License as published by      *
* the Free Software Foundation; either version 2 of the License, or         *
* (at your option) any later version.                                       *
*                                                                           *
* This program is distributed in the hope that it will be useful,           *
* but WITHOUT ANY WARRANTY; without even the implied warranty of            *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
* GNU General Public License (http://www.gnu.org/licenses/gpl.txt)          *
* for more details.                                                         *
*                                                                           *
****************************************************************************/
/****************************************************************************
  History

$Log: not supported by cvs2svn $
Revision 1.16  2007/07/14 12:43:44  benedetti
Added Doxygen documentation.

Revision 1.15  2007/06/13 17:15:08  benedetti
Added one-level undo system and sticky trackmodes.

Revision 1.14  2007/05/15 15:00:47  benedetti
Moved the drawing code to trackmodes, some other minor changes

Revision 1.13  2007/02/26 01:30:02  cignoni
Added reflection Name

Revision 1.12  2007/01/15 15:04:15  tarini
added "ToAscii" and "SetFromAscii" methods to load/store current trackball status from/to ascii strings
(intended uses: clipboard operations and comments inside png snapshots!)

Revision 1.11  2006/08/23 15:40:57  marfr960
*** empty log message ***

Revision 1.10  2006/02/13 13:15:52  cignoni
Added Scale and Translate methods.
Added many drawing hints and raised the default num. of steps when drawing circles.
Added MouseDown without coords (for remembering changes of keys modifiers)
Added ZMode to the default modes under Alt+left
Added DrawPostApply (to be completed)

Revision 1.9  2005/10/17 01:29:46  cignoni
Main restructuring. Removed the Draw function and slightly changed the meaning of the trackball itself.
See the notes at the beginning of trackball.h

Revision 1.8  2004/07/11 22:06:56  cignoni
Added scaling by wheel

Revision 1.7  2004/06/09 14:01:13  cignoni
Heavily restructured. To be completed only rotation works...

Revision 1.6  2004/05/14 03:15:09  ponchio
Redesigned partial version.

Revision 1.5  2004/05/12 20:55:18  ponchio
*** empty log message ***

Revision 1.4  2004/05/07 12:46:08  cignoni
Restructured and adapted in a better way to opengl

Revision 1.3  2004/04/07 10:54:10  cignoni
Commented out unused parameter names and other minor warning related issues

Revision 1.2  2004/03/25 14:55:25  ponchio
Adding copyright.


****************************************************************************/
#ifndef TRACKBALL_H
#define TRACKBALL_H

#include <time.h>
#include <vcg/math/similarity.h>
#include <vcg/space/color4.h>
#include <wrap/gui/view.h>
#include <wrap/gui/trackmode.h>
#include <list>
#include <vector>
#include <map>

namespace vcg {
class Transform {
public:
  Transform();
  Similarityf track;
  Point3f center; 
  float radius; 
};

Transform interpolate(const Transform &a, const Transform &b, float t);

class TrackMode;

class Trackball: public Transform {
public:

  enum Button { BUTTON_NONE   = 0x0000, 
                BUTTON_LEFT   = 0x0001, 
                BUTTON_MIDDLE = 0x0002, 
                BUTTON_RIGHT  = 0x0004, 
                WHEEL         = 0x0008, 
                KEY_SHIFT     = 0x0010, 
                KEY_CTRL      = 0x0020, 
                KEY_ALT       = 0x0040, 
                HANDLE        = 0x0080, 
                                                                MODIFIER_MASK = 0x00FF, 
                                                                KEY_UP        = 0x0100, 
                                                                KEY_DOWN      = 0x0200, 
                                                                KEY_LEFT      = 0x0400, 
                                                                KEY_RIGHT     = 0x0800, 
                                                                KEY_PGUP      = 0x1000, 
                                                                KEY_PGDOWN    = 0x2000, 
              };

  Trackball();
  ~Trackball();
        
        private:
        // Trackball must not be copied. Use Append (see vcg/complex/trimesh/append.h)
        Trackball operator =(const Trackball &  /*m*/){ assert(0); return *this; }
        public:
  void SetIdentity();
  void SetPosition(const Point3f &c, int millisec = 0);
  void SetScale(const float s) {radius=s;};
  void SetTransform(const Transform &transform, int millisec = 0);
  void Translate(Point3f tr);
  void Scale(const float f);

  //operating
  void GetView();

  void Apply ();

  void DrawPostApply();

  void ApplyInverse();
  // DrawIcon() has been moved to trackutils.h
  //void DrawIcon();
  
  // T(c) S R T(t) T(-c) => S R T(S^(-1) R^(-1)(c) + t - c)
  Matrix44f Matrix() const;
  Matrix44f InverseMatrix() const;

  void Reset();

  void ClearModes();

  // DrawCircle (), DrawPlane(), DrawPlaneHandle() has been moved to trackutils.h
  // the drawing code has been moved to the trackmodes
  // void DrawCircle ();
  // void DrawPlane();
  // void DrawPlaneHandle();

  //interface
  void MouseDown(/*Button*/ int button);
  void MouseDown(int x, int y, /*Button*/ int button);
  void MouseMove(int x, int y); 
  void MouseUp(int x, int y, /*Button */ int button); 
  void MouseWheel(float notch);
  void MouseWheel (float notch, /*Button */ int button);
  void ButtonUp(Button button);
  void ButtonDown(Button button, unsigned int msec=0);
  void Undo();

  //default sensitivity 1
  void SetSensitivity(float s);

  void SetSpinnable(bool on);

        
        // returns if it is animating or not
        // 
        bool IsAnimating(unsigned int msec=0);

        // Animate: either takes an absolute time (if default not specified, then it is automeasured)
        // or a fixed delta
        void Animate(unsigned int msec=0);

        bool IsSpinnable();
  void SetSpinning(Quaternionf &spin);
  void StopSpinning();
  bool IsSpinning();

  //interfaccia navigation:
  void Back();
  void Forward();
  void Home();
  void Store();
  void HistorySize(int lenght);

/*    //internals  // commented out no more used this stuff!
    enum Action { NONE = 0,
                  VIEW_ROTATE = 1,
                  // Axis Constrained Rotation 
                  TRACK_ROTATE_X = 3, TRACK_ROTATE_Y = 4, TRACK_ROTATE_Z = 5,
                  // Drag constrained to an axis (trackball axis)
                  DRAG_X = 6,   DRAG_Y = 7,   DRAG_Z = 8,
                  // Drag constrained to a plane
                  DRAG_XY = 9,  DRAG_YZ = 10,  DRAG_XZ = 11,
                  //scale model respect to center of trackball
                  VIEW_SCALE = 12,
                  //scale trackball and model
                  TRACK_SCALE = 13
    };
*/
  // loads stores current status from/to ascii stings
  void ToAscii(char * st);
  bool SetFromAscii(const char * st);

  //protected:
  View<float> camera;
  void SetCurrentAction();
  int current_button;
  TrackMode *current_mode;

  TrackMode *inactive_mode;
  
  // The manipulator to deal with timer events and key events
  TrackMode *idle_and_keys_mode; 
  void setDefaultMapping ();

  std::map<int, TrackMode *> modes;

  // undo_track and last_track have different meanings..
  Similarityf last_track;
  Similarityf undo_track; 
  Similarityf last_view;
  Point3f last_point;
  std::vector<Point3f> Hits;
  bool dragging;
  int button_mask;

        unsigned int last_time;

  Quaternionf spin;
  bool spinnable;
  bool spinning;

  std::list<Transform> history;
  int history_size;


        void SetFixedTimesteps(bool mode){
                fixedTimestepMode=mode;
        }

  friend class TrackMode;
private:
        void Sync(unsigned int msec);
        bool fixedTimestepMode; // if true, animations occurs at fixed time steps

};


}//namespace

#endif