trackmode.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.15  2007/07/14 12:43:44  benedetti
Added Doxygen documentation.

Revision 1.14  2007/07/09 22:47:18  benedetti
Removed using namespace std and modified accordingly.

Revision 1.13  2007/06/25 10:21:38  fiorin
Added some std:: here and there

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

Revision 1.11  2007/05/15 14:59:10  benedetti
Main restructuring. added many new modes

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

Revision 1.9  2006/02/13 13:10:27  cignoni
Added Zmode for moving objects along the perpendicular to the viewplane

Revision 1.8  2004/07/18 06:54:08  cignoni
Added Scaling

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

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

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

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:11  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 TRACKMODE_H
#define TRACKMODE_H

#include <vcg/space/line3.h>
#include <vcg/space/plane3.h>
#include <vcg/space/segment3.h>
#include <vcg/space/ray3.h>
#include <wrap/gui/view.h>

namespace vcg {

class Trackball;

class TrackMode {
public:
  virtual ~TrackMode () {
  }
  virtual void Apply (Trackball * trackball, Point3f new_point);
  virtual void Apply (Trackball * trackball, float WheelNotch);
  virtual void SetAction ();
  virtual void Reset ();
  virtual const char *Name (){
    return "TrackMode";
  };
  virtual void Draw (Trackball * trackball);
  virtual bool isSticky();
  virtual void Undo();

        virtual bool IsAnimating(const Trackball *tb);
        virtual void Animate(unsigned int msec, Trackball *tb);
}; 

class InactiveMode:public TrackMode {
public:
  const char *Name () {
    return "InactiveMode";
  };
 void Draw (Trackball * trackball);
};

/* View space modes */

// old interfaces
/*
class SphereMode: public TrackMode {
}
class CylinderMode: public TrackMode {
}
class PlaneMode: public TrackMode {
}
class ZMode: public TrackMode {
}
class LineMode: public TrackMode {
}
class LineMode: public TrackMode {
}
class ScaleMode: public TrackMode {

*/

// Sphere mode.
class SphereMode:public TrackMode {
public:
  void Apply (Trackball * trackball, Point3f new_point);
  const char *Name () {
    return "SphereMode";
  };
  void Draw (Trackball * trackball);
};

// Panning mode.
class PanMode:public TrackMode {
public:
  void Apply (Trackball * trackball, Point3f new_point);
  const char *Name () {
    return "PanMode";
  };
 void Draw (Trackball * trackball);
};

// Z mode.
class ZMode:public TrackMode {
public:
  const char *Name () {
    return "ZMode";
  };
  void Apply (Trackball * trackball, Point3f new_point);
  void Apply (Trackball * trackball, float WheelNotch);
  void Draw (Trackball * trackball);
};

// Scale Mode.
class ScaleMode:public TrackMode {
public:
  const char *Name () {
    return "ScaleMode";
  };
  void Apply (Trackball * trackball, Point3f new_point);
  void Apply (Trackball * trackball, float WheelNotch);
  void Draw (Trackball * trackball);
};

// Axis mode.
class AxisMode:public TrackMode {
public:
  AxisMode (const Line3f & ln)
    : axis (ln) {
  }
  AxisMode (const Point3f & origin, const Point3f & direction)
    : axis(Line3fN (origin, direction)) {
  }
  const char *Name () {
    return "AxisMode";
  };
  void Apply (Trackball * trackball, Point3f new_point);
  void Apply (Trackball * trackball, float WheelNotch);
  void Draw (Trackball * trackball);
private:
  Line3fN axis;
};

// Plane mode.
class PlaneMode:public TrackMode {
public:
  PlaneMode (float a, float b, float c, float d)
    : plane(Plane3f(d,Point3f(a,b,c))){
  }
  PlaneMode (Plane3f & pl)
    : plane(pl) {
  }
 const char *Name () {
    return "PlaneMode";
  };
  void Apply (Trackball * trackball, Point3f new_point);
  void Draw (Trackball * trackball);
private:
  Plane3f plane;
};

// Cylinder mode.
class CylinderMode:public TrackMode {
public:
  CylinderMode (Line3fN & ln,float s=0.0f)
    : axis (ln), snap(s){
    assert(snap>=0.0);
  }
  CylinderMode (const Point3f & origin, const Point3f & direction,float s=0.0f)
    : axis (Line3fN(origin,direction)), snap(s){
    assert(snap>=0.0);
  }
  const char *Name () {
    return "CylinderMode";
  };
  void Apply (Trackball * trackball, Point3f new_point);
  void Apply (Trackball * trackball, float WheelNotch);
  void Draw (Trackball * trackball);
private:
  Line3fN axis;
  float snap;
};

// Path mode.
class PathMode:public TrackMode {
public:
  PathMode ( const std::vector < Point3f > &pts, bool w = false)
    : points(), wrap(w), current_state(0), initial_state(0), old_hitpoint()
  {
    Init(pts);
    assert(min_seg_length > 0.0f);
  }
  PathMode ( const Point3f &start, const Point3f &end )
    : points(), wrap(false), current_state(0), initial_state(0), old_hitpoint()
  {
    points.push_back(start);    
    points.push_back(end); 
    path_length=Distance(start,end);
    min_seg_length=path_length;
    assert(min_seg_length > 0.0f);
  }
  const char *Name () {
    return "PathMode";
  };
  void Apply (Trackball * trackball, Point3f new_point);
  void Apply (Trackball * trackball, float WheelNotch);
  void Draw (Trackball * trackball);
  void SetAction ();
  void Reset (); 
  Point3f SetStartNear(Point3f p);
  bool isSticky();
  void Undo();
private:
  void Init(const std::vector < Point3f > &points);
  void GetPoints(float state, Point3f & point, Point3f & prev_point, Point3f & next_point);
  float Normalize(float state);
  float HitPoint(float state, Ray3fN ray, Point3f &hit_point);
  int Verse(Point3f reference_point,Point3f current_point,Point3f prev_point,Point3f next_point);

  std::vector < Point3f > points;
  bool wrap;
  float current_state;
  float initial_state;
  float path_length;
  float min_seg_length;
  Point3f old_hitpoint;
  float undo_current_state;
  Point3f undo_old_hitpoint;
};

// Area mode.
class AreaMode:public TrackMode {
public:
  AreaMode (const std::vector < Point3f > &pts)
  {
    Init(pts);
    assert(min_side_length > 0.0f);
  }
  const char *Name () {
    return "AreaMode";
  };
  void Apply (Trackball * trackball, Point3f new_point);
  void Draw (Trackball * trackball);
  void SetAction ();
  void Reset (); 
  Point3f SetStartNear(Point3f p);
  bool isSticky();
  void Undo();
private:
  void Init(const std::vector < Point3f > &pts);
  bool Inside(Point3f point);
  Point3f Move(Point3f start,Point3f end);

  std::vector < Point3f > points;
  bool begin_action;
  int first_coord_kept;
  int second_coord_kept;
  float min_side_length;
  Point3f status;
  Point3f delta_mouse;
  Point3f old_status;
  Point3f initial_status;
  Plane3f plane;
  Point3f rubberband_handle ;
  std::vector < Point3f > path;
  bool undo_begin_action;
  Point3f undo_status;
  Point3f undo_delta_mouse;
  Point3f undo_old_status;
  Point3f undo_rubberband_handle;
  size_t undo_path_index;

};

// Polar mode.
/* WARNING this mode is not compatible with the other rotation modes */

class PolarMode:public TrackMode {
public:
  PolarMode(): alpha(0), beta(0), enda(0), endb(0) {}
   void Apply (Trackball * trackball, Point3f new_point);

  const char *Name () {
    return "PolarMode";
  };
  void SetAction();
  void Reset(); 
 void Draw (Trackball * trackball);
private:
 float alpha, beta; //rotation in y and x axis
 float enda, endb;  //store intermediate values of alpha and beta
};

class NavigatorWasdMode:public TrackMode {
public:
  NavigatorWasdMode();
  
        void Apply (Trackball * trackball, Point3f new_point);

  const char *Name () {
    return "NavigatorWasdMode";
  };
  //void SetAction();
  void Reset(); 
  //void Draw (Trackball * trackball);  
        
        bool isSticky();
        bool IsAnimating(const Trackball *tb);
        void Animate(unsigned int msec, Trackball *tb);
        void SetAction ();
        
        void FlipH(), FlipV(); // flips mouse controls
        
        void SetTopSpeedsAndAcc(float speed_h, float speed_v, float acc=0.0); // (top) speed is in units on sec
                             // Acc is in units on sec^2, if 0 then no-inertia
                             
        void SetStepOnWalk(float width, float height); // optionally, set step-on-walk effects

  void Apply (Trackball * trackball, float WheelNotch);

private:
  float alpha, beta; //rotation in y and x axis
        Point3f current_speed;
        float step_current, step_last, step_x;

        int _flipH, _flipV;
        
        float accX, accY, accZ, dumping, topSpeedH, topSpeedV;
        float step_height, step_length; // height of steps
};

}//namespace 

#endif