/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2003 Robert Osfield 
 *
 * This library is open source and may be redistributed and/or modified under  
 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or 
 * (at your option) any later version.  The full license is in LICENSE file
 * included with this distribution, and on the openscenegraph.org website.
 * 
 * This library 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 
 * OpenSceneGraph Public License for more details.
*/

#ifndef OSSIM_PLANETMANIPULATOR
#define OSSIM_PLANETMANIPULATOR 1

#include <osgGA/MatrixManipulator>
#include <osg/Quat>
#include <ossim/base/ossimGpt.h>
#include "ossimPlanetExport.h"

class OSSIMPLANET_EXPORT ossimPlanetManipulator : public osgGA::MatrixManipulator
{
public:
   
   ossimPlanetManipulator();
   
   virtual const char* className() const { return "ossimPlanetManipulator"; }
   
   /** set the minimum distance (as ratio) the eye point can be zoomed in towards the
       center before the center is pushed forward.*/        
   void setMinimumDistance(float minimumDistance) { theMinimumAltitude=minimumDistance; }
   
   /** get the minimum distance (as ratio) the eye point can be zoomed in */
   float getMinimumDistance() const { return theMinimumAltitude; }
   
   
   /** set the position of the matrix manipulator using a 4x4 Matrix.*/
   virtual void setByMatrix(const osg::Matrixd& matrix);
   
   /** set the position of the matrix manipulator using a 4x4 Matrix.*/
   virtual void setByInverseMatrix(const osg::Matrixd& matrix) { setByMatrix(osg::Matrixd::inverse(matrix)); }
   
   /** get the position of the manipulator as 4x4 Matrix.*/
   virtual osg::Matrixd getMatrix() const;
   
   /** get the position of the manipulator as a inverse matrix of the manipulator, typically used as a model view matrix.*/
   virtual osg::Matrixd getInverseMatrix() const;
   
   /** Get the FusionDistanceMode. Used by SceneView for setting up setereo convergence.*/
   virtual osgUtil::SceneView::FusionDistanceMode getFusionDistanceMode() const { return osgUtil::SceneView::USE_FUSION_DISTANCE_VALUE; }
   
   /** Get the FusionDistanceValue. Used by SceneView for setting up setereo convergence.*/
   virtual float getFusionDistanceValue() const { return _distance; }
   
   /** Attach a node to the manipulator. 
       Automatically detaches previously attached node.
       setNode(NULL) detaches previously nodes.
       Is ignored by manipulators which do not require a reference model.*/
   virtual void setNode(osg::Node*);
   
   /** Return node if attached.*/
   virtual const osg::Node* getNode() const;
   
   /** Return node if attached.*/
   virtual osg::Node* getNode();
   
   /** Move the camera to the default position. 
       May be ignored by manipulators if home functionality is not appropriate.*/
   virtual void home(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter& us);
   
   /** Start/restart the manipulator.*/
   virtual void init(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter& us);
   
   /** handle events, return true if handled, false otherwise.*/
   virtual bool handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter& us);
   
   /** Get the keyboard and mouse usage of this manipulator.*/
   virtual void getUsage(osg::ApplicationUsage& usage) const;
   
protected:
   
   virtual ~ossimPlanetManipulator();
   
   /** Reset the internal GUIEvent stack.*/
   void flushMouseEventStack();
   /** Add the current mouse GUIEvent to internal stack.*/
   void addMouseEvent(const osgGA::GUIEventAdapter& ea);
   
   void computePosition(const osg::Vec3d& eye,const osg::Vec3d& lv,const osg::Vec3d& up);
   
   /** For the give mouse movement calculate the movement of the camera.
       Return true is camera has moved and a redraw is required.*/
   bool calcMovement();
   
   void trackball(osg::Vec3& axis,double& angle, double p1x, double p1y, double p2x, double p2y, double r);
   double tb_project_to_sphere(double r, double x, double y);
   
   /** Check the speed at which the mouse is moving.
       If speed is below a threshold then return false, otherwise return true.*/
   bool isMouseMoving();
   bool computeIntersectionPoint(osg::Vec3d& intersection,
                                 const osg::Vec3d& startPt = osg::Vec3d(0,0,0),
                                 const osg::Vec3d& endPt=osg::Vec3d(0,0,0));
   osg::Vec3d eyePosition()const;
   // Internal event stack comprising last three mouse events.
   osg::ref_ptr<const osgGA::GUIEventAdapter> _ga_t1;
   osg::ref_ptr<const osgGA::GUIEventAdapter> _ga_t0;
   
   osg::ref_ptr<osg::Node> _node;
   
   double                  theMinimumAltitude;
   
   bool                    _thrown;
   
   osg::Vec3d              _center;
   osg::Quat               _rotation;
   double                  _distance;
   double                  theCurrentAltitude;
   double                  theMaxAltitude;
};


#endif