QtBaseViewer.hh

/*===========================================================================*\
 *                                                                           *
 *                              OpenFlipper                                  *
 *      Copyright (C) 2001-2009 by Computer Graphics Group, RWTH Aachen      *
 *                           www.openflipper.org                             *
 *                                                                           *
 *---------------------------------------------------------------------------*
 *  This file is part of OpenFlipper.                                        *
 *                                                                           *
 *  OpenFlipper is free software: you can redistribute it and/or modify      *
 *  it under the terms of the GNU Lesser General Public License as           *
 *  published by the Free Software Foundation, either version 3 of           *
 *  the License, or (at your option) any later version with the              *
 *  following exceptions:                                                    *
 *                                                                           *
 *  If other files instantiate templates or use macros                       *
 *  or inline functions from this file, or you compile this file and         *
 *  link it with other files to produce an executable, this file does        *
 *  not by itself cause the resulting executable to be covered by the        *
 *  GNU Lesser General Public License. This exception does not however       *
 *  invalidate any other reasons why the executable file might be            *
 *  covered by the GNU Lesser General Public License.                        *
 *                                                                           *
 *  OpenFlipper 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 Lesser General Public License for more details.                      *
 *                                                                           *
 *  You should have received a copy of the GNU LesserGeneral Public          *
 *  License along with OpenFlipper. If not,                                  *
 *  see <http://www.gnu.org/licenses/>.                                      *
 *                                                                           *
\*===========================================================================*/

/*===========================================================================*\
 *                                                                           *
 *   $Revision: 8520 $                                                         *
 *   $Author: moebius $                                                      *
 *   $Date: 2010-02-10 15:56:59 +0100 (Mi, 10. Feb 2010) $                   *
 *                                                                           *
\*===========================================================================*/




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

#ifndef BASEVIEWER_HH
#define BASEVIEWER_HH

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

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

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

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

#include <QtOpenGL/QGLFormat>
#include <QBoxLayout>
#include <QtNetwork/QUdpSocket>
#include <QWheelEvent>
#include <QDropEvent>
#include <QContextMenuEvent>
#include <QDragEnterEvent>
#include <QMouseEvent>
#include <QAction>
#include <QKeyEvent>
#include <QSize>
#include <QMap>
#include <QString>
#include <QMenu>
#include <QToolBar>
#include <QTime>
#include <QTimer>
#include <QGraphicsWidget>
#include <QGraphicsSceneDragDropEvent>

#include <vector>
#include <string>


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


class QPushButton;
class QToolButton;
class QSplitter;
class QTimer;
class QImage;
class QSocketNotifier;
class QGLFramebufferObject;


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

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

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


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


class DLLEXPORT glViewer : public QGraphicsWidget
{
Q_OBJECT

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

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

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

  virtual ~glViewer();





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

  virtual QSize sizeHint () const;

  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, 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 setSceneCenter( const ACG::Vec3d& _center );

  void setTrackBallCenter( const ACG::Vec3d& _center );

  const ACG::Vec3d trackBallCenter( ) { return trackball_center_; };

  const ACG::Vec3d& scene_center() const { return scene_center_; }
  double scene_radius() const { return scene_radius_; }

  void viewingDirection( const ACG::Vec3d& _dir, const ACG::Vec3d& _up );

  enum NormalsMode {
    DONT_TOUCH_NORMALS,
    NORMALIZE_NORMALS
  };

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


  ACG::GLMatrixd& light_matrix() { return light_matrix_; }
  void rotate_lights(ACG::Vec3d& _axis, double _angle);
  void update_lights();

  void draw_lights();


  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;

  void encodeView(QString& _view);
  bool decodeView(const QString& _view);

  void initModelviewMatrix();

  // get all Mouse & Key Events for GlWidget
  void grabGLArea();

  // undo grabbing GLArea
  void releaseGLArea();

  void drawBlendedObjects(bool _status) { blending_ = _status; }

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

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

  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 flyTo(const QPoint& _pos, bool _move_back);
  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,
                               double       _time = 1000.0);

  virtual void perspectiveProjection();
  virtual void orthographicProjection();
  virtual void toggleProjectionMode();
  virtual void toggleNavigationMode();

  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();
  void actionCopyView();

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

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

  void signalMouseEvent(QMouseEvent*);

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

  void signalMouseEventIdentify( 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 void initializeGL();
  virtual void paintGL();
  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);

  void lightMouseEvent( QMouseEvent* /* _event */ );


  protected:


  void updateProjectionMatrix();


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

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

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

//----------------------------------------------------------- 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();
  // helper called by drawScene().
  void drawScene_mono();
  // helper called by drawScene() when stereo viewing is active.
  void drawScene_stereo();

  // helper called by drawScene_stereo() when opengl stereo viewing is active.
  void drawScene_glStereo();

  // helper called by drawScene_stereo() when anaglyph stereo viewing is active.
  void drawScene_anaglyphStereo();

  // helper called by drawScene_stereo() when custom anaglyph stereo viewing is active.
  void drawScene_customAnaglyphStereo();

  // helper called to initialize/update custom anaglyph stereo
  void updateCustomAnaglyphStereo();

  // helper called to cleanup custom anaglyph stereo
  void finiCustomAnaglyphStereo();

  // Draws the scene for a philips stereo display ( Header, left color image, right depth map )
  void drawScenePhilipsStereo();

  // Updates the scene for a philips stereo display
  void updateScenePhilipsStereo();

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


  // scene center and radius
  ACG::Vec3d                   scene_center_, trackball_center_;
  double                       scene_radius_, trackball_radius_;


  // projection stuff
  GLdouble                     orthoWidth_;
  GLdouble                     near_, far_, fovy_;

  // 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_;


  // matrix for rotating light position
  ACG::GLMatrixd               light_matrix_;


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


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


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

  bool                         projectionUpdateLocked_;
  bool                         blending_;

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

  // gl widget used as drawing area to paint the graphics scene
  QGLWidget* 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
  QTime redrawTime_;

  // Used to draw the current cursor in the scene
  CursorPainter *cursorPainter_;

  // position of the cursor picked into the scenegraph
  ACG::Vec3d cursorPoint3D_;

  // indicates that we successfully mapped the cursor into the scene
  bool cursorPositionValid_;

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

  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 slots:

    virtual void setStereoMode(bool _b);

  private:
    // stereo stuff
    bool                         stereo_;

    // custom anaglyph stuff
    int    agTexWidth_;
    int    agTexHeight_;
    GLuint agTexture_[2];
    GLuint agProgram_;
    bool   customAnaglyphSupported_;

    // Philips stereo mode stuff
    int     pTexWidth_;
    int     pTexHeight_;
    ACG::Texture2D pColorTexture_;
    ACG::Texture2D pDepthStencilTexture_;
    GLSL::PtrProgram pProgram_;
    bool philipsStereoInitialized_;

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

  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();

    virtual void snapshot(QImage& _image, bool _offScreenRendering = false);

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

    bool pick_region( ACG::SceneGraph::PickTarget                _pickTarget,
                      const QRegion&                             _region,
                      QList<QPair<unsigned int, unsigned int> >& _list);

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

  private:

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

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

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

  private:

    QGLFramebufferObject *pickCache_;

    bool updatePickCache_;

    ACG::SceneGraph::PickTarget pickCacheTarget_;

    bool pickCacheSupported_;

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

  public:

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

  private slots:

    void slotAnimation();

  protected:

    // mouse interaction
    QPoint   lastPoint2D_;

  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_;
    double                       lastRotationAngle_;
    QTime                        lastMoveTime_;
    QTimer*                      timer_;

    QTimer                       clickTimer_;
    QTime                        clickTime_;
    QMouseEvent                  clickEvent_;

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

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

  private:
    Viewer::ViewerProperties& properties_;

    ACG::GLState                 *glstate_;

    bool initialized_;

  private slots:
    void slotPropertiesUpdated();

  private:
    void applyProperties();

};


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