QtBaseViewer.hh

/*===========================================================================*\
*                                                                            *
*                              OpenFlipper                                   *
 *           Copyright (c) 2001-2015, RWTH-Aachen University                 *
 *           Department of Computer Graphics and Multimedia                  *
 *                          All rights reserved.                             *
 *                            www.openflipper.org                            *
 *                                                                           *
 *---------------------------------------------------------------------------*
 * This file is part of OpenFlipper.                                         *
 *---------------------------------------------------------------------------*
 *                                                                           *
 * Redistribution and use in source and binary forms, with or without        *
 * modification, are permitted provided that the following conditions        *
 * are met:                                                                  *
 *                                                                           *
 * 1. Redistributions of source code must retain the above copyright notice, *
 *    this list of conditions and the following disclaimer.                  *
 *                                                                           *
 * 2. Redistributions in binary form must reproduce the above copyright      *
 *    notice, this list of conditions and the following disclaimer in the    *
 *    documentation and/or other materials provided with the distribution.   *
 *                                                                           *
 * 3. Neither the name of the copyright holder nor the names of its          *
 *    contributors may be used to endorse or promote products derived from   *
 *    this software without specific prior written permission.               *
 *                                                                           *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS       *
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED *
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A           *
 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER *
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,  *
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,       *
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR        *
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF    *
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING      *
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS        *
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.              *
*                                                                            *
\*===========================================================================*/






//=============================================================================
//
//  CLASS glViewer
//
//=============================================================================

#ifndef BASEVIEWER_HH
#define BASEVIEWER_HH

//== INCLUDES =================================================================

#include <OpenFlipper/common/Types.hh>
#include <OpenFlipper/common/ViewerProperties.hh>

#include <OpenFlipper/common/OFGLWidget.hh>

#include <ACG/GL/GLState.hh>
#include <ACG/GL/FBO.hh>
#include <ACG/Scenegraph/SceneGraph.hh>
#include <ACG/QtWidgets/QtSceneGraphWidget.hh>

#include <ACG/ShaderUtils/GLSLShader.hh>
#include <ACG/GL/globjects.hh>

#include <vector>
#include <string>
#include <limits>

#include <QGraphicsWidget>
#include <QTimer>
#include <QMouseEvent>
#include <QTime>
#include <QElapsedTimer>

//== FORWARDDECLARATIONS ======================================================


class QPushButton;
class QToolButton;
class QSplitter;
class QImage;
class QSocketNotifier;
class QPropertyAnimation;
class QFramebufferObject;
struct PostProcessorInput;


//== NAMESPACES ===============================================================

//== FORWARDDECLARATIONS ======================================================

namespace ACG {
  namespace QtWidgets {
    class QtWheel;
  }
}
class QGraphicsScene;
class QtGLViewerLayout;
class QtShiftPopupMenu;
class CursorPainter;
class PostProcessing;


class QOpenGLFramebufferObject;
class QOpenGLFramebufferObjectFormat;


class QOpenGLDebugLogger;
class QOpenGLDebugMessage;


//== CLASS DEFINITION =========================================================


class DLLEXPORT glViewer : public QGraphicsWidget
{
Q_OBJECT

//-------------------------------------------------------------- public methods
public:

  //--------------------------------------------------- constructor / destructor

  glViewer( QGraphicsScene*           _scene,
            OFGLWidget*                _glWidget,
            Viewer::ViewerProperties& _properties,
            QGraphicsWidget*          _parent = 0 );

  virtual ~glViewer();

  //------------------------------------------------------------- public methods


  virtual void makeCurrent();
  virtual void swapBuffers();

  void lockProjectionUpdate( void ) { projectionUpdateLocked_ = true; }

  void unlockProjectionUpdate( void ) { projectionUpdateLocked_ = false; }

  signals :
    void functionMenuUpdate();

    void statusMessage (const QString & message, int timeout = 0);

  public:

  void trackMouse(bool _track);

  void sceneGraph(ACG::SceneGraph::BaseNode* _root,
                  unsigned int               _maxPasses,
                  ACG::Vec3d                 _bbmin,
                  ACG::Vec3d                 _bbmax,
                  const bool _resetTrackBall = false);

  enum ProjectionMode {
    ORTHOGRAPHIC_PROJECTION, 
    PERSPECTIVE_PROJECTION   
  };

  enum NavigationMode {
          NORMAL_NAVIGATION,     
          FIRSTPERSON_NAVIGATION  
  };

  void projectionMode(ProjectionMode _p);
  ProjectionMode projectionMode() const { return projectionMode_; }

  void navigationMode(NavigationMode _n);
  NavigationMode navigationMode() const { return navigationMode_; }

  void setScenePos( const ACG::Vec3d& _center, double _radius, const bool _resetTrackBall = false );

  void viewingDirection( const ACG::Vec3d& _dir, const ACG::Vec3d& _up );
  
  void lookAt(const ACG::Vec3d& _eye, const ACG::Vec3d& _center, const ACG::Vec3d& _up);
  
  enum NormalsMode {
    DONT_TOUCH_NORMALS,
    NORMALIZE_NORMALS
  };

  void normalsMode(NormalsMode _mode);
  NormalsMode normalsMode() const { return normalsMode_; }

  void copyToImage( QImage& _image, GLenum _buffer=GL_BACK) {
    copyToImage(_image, 0, 0, glWidth(), glHeight(), _buffer);
  }

  void copyToImage( QImage& _image,
                    unsigned int _left,  unsigned int _top,
                    unsigned int _width, unsigned int _height,
                    GLenum _buffer );


  unsigned int glWidth() const;
  unsigned int glHeight() const;
  QSize glSize() const;
  QPoint glMapFromGlobal( const QPoint& _pos ) const;
  QPoint glMapToGlobal( const QPoint& _pos ) const;

  double field_of_view_vertical() const;

  double aspect_ratio() const {
      if (isVisible() && glWidth() && glHeight())
        return (double) glWidth() / (double) glHeight();
      else
        return 1.0;
  }

  double near_plane() const {
      return properties_.nearPlane();
  }

  double far_plane() const {
      return properties_.farPlane();
  }

  double ortho_width() const {
      return properties_.orthoWidth();
  }

  void encodeView(QString& _view, const QSize& _windowSize = QSize(-1,-1),
          const int _toolBarWidth = -1, const bool _make_c_string = false);

  static bool decodeView(const QString& _view,
          ACG::GLMatrixd &m, ACG::GLMatrixd &p, int &pMode, double &ortho_width,
          QSize *_windowSize = NULL,
          int* _splitterWidth = NULL, QSize *_viewportSize = NULL);

  bool decodeView(const QString& _view, QSize *_windowSize = NULL,
          int* _toolBarWidth = NULL, QSize *_viewportSize = NULL);

  void initModelviewMatrix();

  void grabGLArea();

  void releaseGLArea();

  void translate(const ACG::Vec3d& trans);

  void rotate(const ACG::Vec3d& axis, double angle)
  { rotate(axis, angle, properties_.trackballCenter()); }

  void rotate(const ACG::Vec3d& axis, double angle, const ACG::Vec3d& _center);

  void setCursorPainter (CursorPainter *_cursorPainter);

  void updateCursorPosition (QPointF _scenePos);

  void moveForward();

  void moveBack();

  void strafeLeft();

  void strafeRight();

//---------------------------------------------------------------- public slots
public slots:

  virtual void updateGL();

  virtual void setHome();
  virtual void home();
  virtual void viewAll();

  virtual void perspectiveProjection();
  virtual void orthographicProjection();
  virtual void toggleProjectionMode();
  virtual void toggleNavigationMode();
  
  virtual void setFOVY(double _fovy);

  signals:

    void projectionModeChanged( bool _ortho );
    void navigationModeChanged( bool _normal );

  public slots:

  virtual void setView( const ACG::GLMatrixd& _modelview,
                                       const ACG::GLMatrixd& _inverse_modelview );

  void actionPasteView(QSize * _windowSize = NULL, int *_splitterWidth = NULL);
  void actionCopyView(const QSize &_windowSize = QSize(-1,-1), const int _splitterWidth = -1,
          const bool _make_c_string = false);

  void actionSetView(QString view);

//-------------------------------------------------------------- public signals
signals:

  void signalMouseEvent(QMouseEvent*, const std::string&);

  void signalMouseEvent(QMouseEvent*);

  void signalWheelEvent(QWheelEvent*, const std::string&);

  void signalMouseEventIdentify( QMouseEvent* );
  
  void signalMouseEventLight( QMouseEvent* );

  void signalSceneGraphChanged(ACG::SceneGraph::BaseNode* _root);

  void signalMouseEventClick ( QMouseEvent*, bool _double );


  signals:

  void signalCustomContextMenuRequested ( const QPoint & );

  private slots:

  void slotClickTimeout ();


//----------------------------------------------------------- protected methods
protected:

  friend class QtGLGraphicsScene;
  friend class SimpleGLGraphicsScene;
  friend class QtGLGraphicsView;


  //virtual QSizeF sizeHint (Qt::SizeHint which, const QSizeF & constraint) const;

  virtual void initializeGL();
  virtual void paintGL(double _aspect = 0.0);
  virtual void resizeEvent(QGraphicsSceneResizeEvent * _e);
  virtual void moveEvent (QGraphicsSceneMoveEvent * _e);

  virtual void mousePressEvent(QGraphicsSceneMouseEvent* _event);
  virtual void mouseDoubleClickEvent(QGraphicsSceneMouseEvent* _event);
  virtual void mouseMoveEvent(QGraphicsSceneMouseEvent* _event);
  virtual void mouseReleaseEvent(QGraphicsSceneMouseEvent* _event);
  virtual void wheelEvent(QGraphicsSceneWheelEvent* _event);
  virtual void contextMenuEvent(QGraphicsSceneContextMenuEvent* _e);


  void viewMouseEvent( QMouseEvent* _event);
  void viewWheelEvent(QWheelEvent* _event);
  void viewKeyEvent( QKeyEvent* _event);

  
  protected:


  void updateProjectionMatrix(double _aspect = 0.0);


//------------------------------------------------------------- protected slots
protected slots:

  virtual void slotWheelX(double _dAngle);
  virtual void slotWheelY(double _dAngle);
  virtual void slotWheelZ(double _dist);

  virtual void cleanupEventFilter()
  { removeEventFilter( sender());}

  void processGLDebugMessage(const QOpenGLDebugMessage& msg);


//----------------------------------------------------------- private functions
private:

  glViewer(const glViewer&);
  glViewer& operator=(const glViewer&);

  // create widgets
  void createWidgets();

  /* Recursively draws each node in the scene graph.
      Called by paintGL(). */
  void drawScene(double _aspect = 0.0);
  // helper called by drawScene().
  void drawScene_mono();
  void setCoordSysProjection(glViewer::ProjectionMode _mode);
  void drawCursor();
  
  // start QOpenGLDebugLogger
  void startGLDebugLogger();
  void deleteGLDebugLogger();

  // wrapper for glWidget make current
  void makeWidgetCurrent();

  // wrapper to create QFramebufferObject returns true if QFBO is valid if samples is -1 the default samples are retrieved
  bool createQFBO(QOpenGLFramebufferObject*& _ptr, GLuint* _handle, int _width, int _height, int* _samples);
  bool bindQFBO(QOpenGLFramebufferObject* _ptr);
  bool QFBOResized(QOpenGLFramebufferObject* _ptr);
  void blitQFBO(QOpenGLFramebufferObject* _ptr1, const QRect& _size1, QOpenGLFramebufferObject* _ptr2, const QRect& _size2);
  void deleteQFBO(QOpenGLFramebufferObject* _ptr);


//-------------------------------------------------------------- protected data
protected:

  // helper
  bool                         isRotating_;
  bool                         lookAround_;


//---------------------------------------------------------------- private data
private:


  // data stored for home view
  ACG::Vec3d                   home_center_;
  double                       home_radius_;
  ACG::GLMatrixd               home_modelview_,
                               home_inverse_modelview_;
  double                       homeOrthoWidth_;


  // modi
  NormalsMode                  normalsMode_;
  ProjectionMode               projectionMode_;
  NavigationMode               navigationMode_;


  // helper
  bool                         trackMouse_;
  bool                         glareaGrabbed_;
  double                       frame_time_;


  // scenegraph stuff
  ACG::SceneGraph::BaseNode*   sceneGraphRoot_;

  bool                         projectionUpdateLocked_;

  // graphics scene used to paint gl context and widgets
  QGraphicsScene* glScene_;

  // gl widget used as drawing area to paint the graphics scene
  OFGLWidget* glWidget_;

  // Base graphics widget layout
  QtGLViewerLayout* glBaseLayout_;

  // vector of current draw mode actions
  std::vector< QAction * > drawMenuActions_;

  // Used to calculate the time passed between redraws
  QElapsedTimer redrawTime_;

  // Default VAO needed in core profile mode
  ACG::VertexArrayObject defaultVAO_;

  // Get additional debug info from OpenGL
  QOpenGLDebugLogger* glDebugLogger_;


  //===========================================================================
  //===========================================================================

  public:
    bool wheelsVisible();

  public slots:
    void slotShowWheels();
    void slotHideWheels();

  private:
    // rotate around x-axis
    ACG::QtWidgets::QtWheel* wheelX_;
    // rotate around y-axis
    ACG::QtWidgets::QtWheel* wheelY_;
    // translate along z-axis
    ACG::QtWidgets::QtWheel* wheelZ_;


  //===========================================================================
  //===========================================================================
  signals:
    void viewUpdated();

    void viewChanged();

    void signalMakeActive ();

  //===========================================================================
    //===========================================================================
    
    public:
    void setSceneCenter( const ACG::Vec3d& _center ) { properties_.sceneCenter(_center); };
    
    void setTrackBallCenter( const ACG::Vec3d& _center ) { properties_.trackballCenter(_center); }
    
    const ACG::Vec3d trackBallCenter( ) { return properties_.trackballCenter(); };
    
    const ACG::Vec3d scene_center() const { return properties_.sceneCenter(); }
    double scene_radius() const { return properties_.sceneRadius(); }
    
    void setSceneRadius(double _radius) { properties_.sceneRadius(_radius); }
  
  //===========================================================================
  //===========================================================================

  signals:
    void signalKeyPressEvent(QKeyEvent*);

  protected:

    virtual void keyPressEvent(QKeyEvent* _event) { _event->ignore(); };

    virtual void keyReleaseEvent(QKeyEvent* _event) { _event->ignore(); };

    virtual bool viewKeyPressEvent(QKeyEvent* /* _event */ ) { return false; }

  //===========================================================================
  //===========================================================================

  public:

    virtual void dragEnterEvent(QGraphicsSceneDragDropEvent* _e);

    virtual void dropEvent(QGraphicsSceneDragDropEvent* _e);

  signals:
    void startDragEvent( QMouseEvent* _event );

    void dragEnterEvent(QDragEnterEvent* _event);

    void dropEvent( QDropEvent* _event );


  //===========================================================================
  //===========================================================================

  public slots:


    virtual void snapshot(int _width = 0, int _height = 0, bool _alpha = false, bool _hideCoordsys = false, int samples = 1);

    virtual void snapshot(QImage& _image, int _width = 0, int _height = 0, bool _alpha = false, bool _hideCoordsys = false, int samples = 1);

  //===========================================================================
  //===========================================================================
  public:
    bool pick( ACG::SceneGraph::PickTarget _pickTarget,
               const QPoint&               _mousePos,
               size_t&                     _nodeIdx,
               size_t&                     _targetIdx,
               ACG::Vec3d*                 _hitPointPtr=0 );

    bool pick_region( ACG::SceneGraph::PickTarget                _pickTarget,
                      const QRegion&                             _region,
                      QList<QPair<size_t,size_t> >&              _list,
                      QVector<float>*                            _depths = 0,
                      QVector<ACG::Vec3d>*                       _points = 0);


    bool fast_pick( const QPoint&  _mousePos,
                    ACG::Vec3d&    _hitPoint );

    ACG::Vec3d unproject(const ACG::Vec3d &pt) {
        return glstate_->unproject(pt);
    }

  private:

    int pickColor( ACG::SceneGraph::PickTarget _pickTarget,
                   const QPoint& _mousePos,
                   size_t& _nodeIdx,
                   size_t& _targetIdx,
                   ACG::Vec3d*   _hitPointPtr=0 );

    int pickFromCache( ACG::SceneGraph::PickTarget _pickTarget,
                       const QPoint& _mousePos,
                       size_t& _nodeIdx,
                       size_t& _targetIdx,
                       ACG::Vec3d*   _hitPointPtr=0 );

  private:


    typedef QOpenGLFramebufferObjectFormat QFramebufferObjectFormat;
    typedef QOpenGLFramebufferObject QFramebufferObject;


    QFramebufferObject* pickCache_;
    QFramebufferObject* mouseCache_;

    bool updatePickCache_;

    ACG::SceneGraph::PickTarget pickCacheTarget_;

    bool pickCacheSupported_;

  //===========================================================================
  //===========================================================================

  public:

  void allowRotation( bool _mode ) { allowRotation_ = _mode; };
  bool allowRotation() { return allowRotation_; };

  void allowConstrainedRotation(const ACG::Vec3d &axis) {
      constrainedRotationAxis_ = axis;
  }
  bool allowConstrainedRotation() {
      return constrainedRotationAxis_[0] == constrainedRotationAxis_[0];
  }
  const ACG::Vec3d &getConstrainedRotationAxis() {
      return constrainedRotationAxis_;
  }
  void disallowConstrainedRotation() {
      constrainedRotationAxis_[0] = std::numeric_limits<double>::quiet_NaN();
  }
  void invalidatePickCache() {
      updatePickCache_ = true;
  }

  private slots:

    void slotAnimation();

  protected:

    QPoint   lastPoint2D_;
    
    float startDepth_;

  private:

    bool mapToSphere(const QPoint& _p, ACG::Vec3d& _result) const;

    void handleFirstPersonNavigation( QMouseEvent* _event);

    void handleNormalNavigation( QMouseEvent* _event);


    // mouse interaction
    ACG::Vec3d    lastPoint3D_;
    bool          lastPoint_hitSphere_;
    bool          allowRotation_;

    // animation stuff
    ACG::Vec3d                   lastRotationAxis_;
    ACG::Vec3d                   constrainedRotationAxis_;
    double                       lastRotationAngle_;
    QElapsedTimer                lastMoveTime_;
    QTimer*                      timer_;
    double                       fovyModifier_;

    QTimer                       clickTimer_;
    QElapsedTimer                clickTime_;
    QMouseEvent                  clickEvent_;


  //===========================================================================
  //===========================================================================

  public:
    Viewer::ViewerProperties* properties() { return &properties_; };
    const Viewer::ViewerProperties* properties() const { return &properties_; };

  private:
    Viewer::ViewerProperties& properties_;

    ACG::GLState                 *glstate_;

    bool initialized_;

  private slots:
    void slotPropertiesUpdated();

  private:
    void applyProperties();

  //===========================================================================
  //===========================================================================
  public slots:

    virtual void flyTo(const QPoint& _pos, bool _moveBack);

    virtual void flyTo(const QPoint& _pos) { flyTo(_pos,false); }


    virtual void flyFrom(const QPoint& _pos) { flyTo(_pos,true); }

    virtual void flyTo(const ACG::Vec3d& _position,
                       const ACG::Vec3d& _center,
                       int               _time = 1000);

  private:

    QPropertyAnimation* flyAnimationPerspective_;
    QPropertyAnimation* flyAnimationOrthogonal_;

    ACG::Vec3d flyTranslation_;

    ACG::Vec3d flyAxis_;

    double     flyAngle_;

    double     lastAnimationPos_;

    Q_PROPERTY(double currentAnimationPosition READ currentAnimationPos WRITE currentAnimationPos NOTIFY currentAnimationPosChanged)

    
    double     currentAnimationPos_;

    double currentAnimationPos() {return currentAnimationPos_;};

    void   currentAnimationPos(double _currentAnimationPos) {currentAnimationPos_ = _currentAnimationPos; emit currentAnimationPosChanged(_currentAnimationPos); };

    ACG::Vec3d flyCenter_;

    ACG::Vec3d flyPosition_;

    double flyOrthoWidthOriginal_;

    bool flyMoveBack_;

  signals:
    void currentAnimationPosChanged(double _currentAnimationPos);

  private slots:
    void flyAnimationPerspective(QVariant _pos);

    void flyAnimationOrthogonal(QVariant _pos);

    void flyAnimationPerspectiveFinished();

    void flyAnimationOrthogonalFinished();

  //===========================================================================
  //===========================================================================

private:

  void computeProjStereo(int _width, int _height,
    Viewer::ViewerProperties& _properties,
    ACG::GLMatrixd* _outLeft, ACG::GLMatrixd* _outRight);

  //===========================================================================
  //===========================================================================

private:


  PostProcessing* postproc_;


};


//=============================================================================
//=============================================================================
#endif // BASEVIEWER_HH defined
//=============================================================================