View.hpp

Go to the documentation of this file.

/***********************************
 Copyright 2018 Ravishankar Mathur
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
 
 http://www.apache.org/licenses/LICENSE-2.0
 
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 ***********************************/

#ifndef _OF_VIEW_
#define _OF_VIEW_

#include <OpenFrames/Export.h>
#include <OpenFrames/TransformAccumulator.hpp>
#include <osg/Matrixd>
#include <osg/Referenced>
#include <osg/ref_ptr>
#include <osgGA/TrackballManipulator>

namespace OpenFrames
{
  class FollowingTrackball;
  class OF_EXPORT View : public osg::Referenced
  {
  public:
    enum ProjectionType
    {
      ORTHOGRAPHIC=0, // Object size is independent of distance from viewer
      PERSPECTIVE,  // Objects get smaller as they get farther away
    };

    enum ViewFrameType
    {
      // View frame initialized to the scene's global reference frame.
      // This is equivalent to an "inertial-fixed" view that follows
      // the body as it translates.
      // If viewing in from-to mode, then the rotation starts in the
      // scene's global reference frame.
      ABSOLUTE_FRAME=0,

      // View frame initialized to the frame being viewed. This is
      // equivalent to a "body-fixed" view.
      // If viewing in from-to mode, then the rotation starts in the
      // body-fixed reference frame.
      RELATIVE_FRAME
    };

    enum ViewRotationType
    {
      // Single direct rotation, using shortest angle
      // This may result in upside-down view if the rotation angle
      // is greater than 90 degrees out-of-plane
      DIRECT=0,

      // First rotate along X-Y (azimuth), then up Z (elevation)
      // This preserves "Z-up" for the view base frame
      AZEL
    };

    View();
    View(ReferenceFrame *root, ReferenceFrame *viewFrame, ViewFrameType baseframe = RELATIVE_FRAME);
    View(ReferenceFrame *root, ReferenceFrame *viewFrame, ReferenceFrame *lookatFrame, ViewFrameType frameType = RELATIVE_FRAME, ViewRotationType rotationType = AZEL);

    inline ProjectionType getProjectionType() { return _projType; }

    inline void setPerspective(const double fovy, const double ratio)
    {
      _projType = PERSPECTIVE;
      _projection.makePerspective(fovy, ratio, 1, 10000);
    }

    inline void getPerspective(double &fovy, double &ratio) const
    {
      if(_projType == PERSPECTIVE)
      {
        double zNear, zFar;
        _projection.getPerspective(fovy, ratio, zNear, zFar);
      }
    }

    inline void setOrthographic(const double left, const double right,
                                const double bottom, const double top)
    {
      _projType = ORTHOGRAPHIC;
      _projection.makeOrtho(left, right, bottom, top, 1, 10000);
    }

    inline void getOrthographic(double &left, double &right,
                                double &bottom, double &top) const
    {
      if(_projType == ORTHOGRAPHIC)
      {
        double zNear, zFar;
        _projection.getOrtho(left, right, bottom, top, zNear, zFar);
      }
    }

    inline osg::Matrixd getProjectionMatrix() { return _projection; }
    osg::Matrixd getViewMatrix();

    void setDefaultViewDistance(double distance) { _defaultViewDistance = distance; }
    double getDefaultViewDistance() const { return _defaultViewDistance; }

    FollowingTrackball* getTrackball() const { return _trackball.get(); }
    void setTrackball(FollowingTrackball *trackball);
    
    void resetView();

    void saveView();
    void restoreView();

    void setViewFrame( ReferenceFrame* root, ReferenceFrame* viewFrame, ViewFrameType frameType = RELATIVE_FRAME );

    void setViewBetweenFrames( ReferenceFrame* root, ReferenceFrame* viewFrame, ReferenceFrame* lookatFrame, ViewFrameType frameType = RELATIVE_FRAME, ViewRotationType rotationType = AZEL );

    ReferenceFrame* getViewRoot() { return _xform->getRoot(); }
    ReferenceFrame* getViewFrame() { return _xform->getOrigin(); }
    ReferenceFrame* getLookAtFrame() { return _xform_lookat->getOrigin(); }
    ViewFrameType getViewFrameType() { return _frameType; }
    ViewRotationType getViewRotationType() { return _rotationType; }

    inline bool isValid() {return _xform->isValid();}

  protected:
    virtual ~View();
    void _init();

    osg::ref_ptr<TransformAccumulator> _xform;
    ViewFrameType _frameType;
    
    osg::ref_ptr<TransformAccumulator> _xform_lookat;
    ViewRotationType _rotationType;

    ProjectionType _projType;

    osg::Matrixd _projection;

    double _defaultViewDistance;

    osg::ref_ptr<FollowingTrackball> _trackball;
  };

  class OF_EXPORT FollowingTrackball : public osgGA::TrackballManipulator
  {
  public:
    FollowingTrackball();

    virtual const char* className() const { return "FollowingTrackball"; }
    
    // Set the frame transform sources
    void setTransformSources(TransformAccumulator *xform, TransformAccumulator *xform_lookat, View::ViewFrameType frameType, View::ViewRotationType rotationType);

    // Inherited from TrackballManipulator
    virtual osg::Matrixd getMatrix() const; // Get local to world matrix
    virtual osg::Matrixd getInverseMatrix() const; // Get world to local matrix
    virtual bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& us); // Handle event

  protected:
    virtual ~FollowingTrackball();

    // Save, restore, and reset trackball state
    friend class View;
    virtual void saveState();
    virtual void restoreState();
    virtual void resetState();

    // Compute matrix that incorporates custom view transformations
    void computeWorldToViewMatrix(osg::Matrixd &matrix) const;

    // The ReferenceFrame being followed.
    osg::observer_ptr<TransformAccumulator> _xform, _xform_lookat;
    View::ViewFrameType _frameType;
    View::ViewRotationType _rotationType;
  };

} // !namespace OpenFrames

#endif