---

qglvuwidget.h

#ifndef __QGLVUWIDGET_H__
#define __QGLVUWIDGET_H__

#include <qgl.h>
#include <sys/timeb.h> // for frame timing

// GLVU includes
#include <camera.hpp>


class QGLVUWidget : public QGLWidget
{
  Q_OBJECT
public: // Constants
  
  enum WorldNavMode 
  {
    NAV_MODE_TRACKBALL, 
    NAV_MODE_HYPERBALL,
    NAV_MODE_DRIVE, 
    NAV_MODE_TRANSLATE, 
    NAV_MODE_LOOK,
    NAV_MODE_NUM_MODES
  };
  
  enum CameraID
  {
    CAMERA_ONE,
    CAMERA_TWO,
    CAMERA_THREE,
    CAMERA_FOUR,
    CAMERA_NUM_CAMS
  };
  
public: // Methods
  QGLVUWidget(QGLFormat &format = QGLFormat::defaultFormat(), 
              QWidget* parent = 0, 
              const char* name = 0 );
  virtual ~QGLVUWidget();
  
  virtual void        DoneCurrent();
  void                MakeContextCurrent();
                      
  virtual void        BeginFrame();
  virtual void        EndFrame();
                      
  inline void         SetCurrentCam(Camera *pNewCam);     
  inline Camera*      GetCurrentCam();
  inline Camera*      GetCam(int whichCam);
  
  void                SetOrigCam(Camera *pCam);
  
  void                SetAllCams(Vec3f worldMin, Vec3f worldMax, Vec3f eye, 
                                 Vec3f lookAtCntr, Vec3f viewup,
                                 float yFOV, float aspect, 
                                 float nearFactor, float farFactor);
                      
  void                AllCamsPerspectiveChange(float yFOV, float aspect, 
                                               float nearDist, float farDist);
  void                AllCamsPerspectiveAspectChange(float aspect);
                      
  float*              GetModelviewMatrix(float* pMatrix) const;
  float*              GetProjectionMatrix(float* pMatrix) const;                                                      
                      
  inline bool         GetInOutMode() const;
  inline void         SetInOutMode(bool bMode);
                      
  inline int          GetWorldNavMode() const;
  
  inline const Vec3f& GetViewUp() const;
  inline const Vec3f& GetWorldCenter() const;
  inline float        GetWorldRadius() const;
  inline void         SetViewUp(Vec3f viewup);
  inline void         SetWorldCenter(const Vec3f& center);
  inline void         SetWorldRadius(float newRadius);
  
  inline bool         GetCamDisplayOn(int whichCam) const;
  
  inline bool         GetInertiaOn() const;
  inline bool         GetInertiaEnabled() const;
  inline int          GetInertiaDelay() const;
  void                SetInertiaOn( bool bEnable );
  inline void         SetInertiaEnabled( bool bEnable);  
  inline void         SetInertiaDelay(int iMilliseconds);
  inline int          GetInertiaMinMove() const;    
  inline void         SetInertiaMinMove( int iAmount );
  
  inline void         StartFPSClock();
  inline void         StopFPSClock(); 
  inline float        GetFPS() const;
  inline void         SetFPSIntegrateInterval(float rInterval);

  // use only if you do not call QGLVUWidget::BeginFrame()
  void                UpdateFPS();                         
  
  inline ButtonState  GetButtonState() const;
  inline void         GetMousePos(int &ix, int &iy) const;
  
  //           Movement functions
  void                TranslateX(int iOldX, int iNewX, int iWW);
  void                TranslateY(int iOldY, int iNewY, int iWH);
  void                DriveY(int iOldY, int iNewY, int iWH);
  void                LookX(int iOldX, int iNewX, int iWW);
  void                LookY(int iOldY, int iNewY, int iWH);
  void                TrackBallX(int iOldX, int iNewX, int iWW);
  void                TrackBallY(int iOldY, int iNewY, int iWH);
  void                HyperBall( int iOldX, int iOldY, 
                                 int iNewX, int iNewY,
                                 int iWW, int iWH);
  
  void                SnapShot();
  void                ReportGLError(char *msg);
  QPixmap*            CreateQGLVUPixmap() const;
                      
  //                  Path Recording and playback.
  void                SetPathFilename(const char *pFilename);
  void                StartRecording();
  void                EndRecording();
  void                StartPlayback();
  void                EndPlayback();
  void                StopRecordingPlayback();
                    
  //                  Replace default GL methods
  void                SetInitializeGL(void (*f)(QGLVUWidget*));
  void                SetResizeGL(void (*f)(QGLVUWidget*, int, int));
  void                SetPaintGL(void (*f)(QGLVUWidget*));
  
  // Default implementations.  Can be replaced with Set*GL() methods
  static void         DefaultInitializeGL(QGLVUWidget* pGLVU);
  static void         DefaultResizeGL(QGLVUWidget* pGLVU, int iw, int ih );
  static void         DefaultPaintGL(QGLVUWidget* pGLVU);
                      
public slots:         
  inline void         SelectCam( int whichCam ); 
  void                AllCamsResetToOrig();
  void                CyclePolygonMode();
  inline int          SetWorldNavMode(WorldNavMode mode);
  bool                ToggleCamDisplay( int whichCam );           
  bool                ToggleInOutMode();
  bool                ToggleFaceCulling();
  bool                ToggleLighting();
  bool                ToggleMaterials();
  bool                ToggleSmoothShading();
  void                ToggleCullFace();
  
signals:
  void                FPSUpdate(float rFPS);

protected: // Methods
  virtual void        initializeGL();
  virtual void        resizeGL( int iw, int ih );
  virtual void        paintGL();
  

protected: // Events
  
  // These are inherited from QWidget.  Can override in a subclass.
  virtual void        mousePressEvent( QMouseEvent *pEvent );
  virtual void        mouseReleaseEvent( QMouseEvent *pEvent ); 
  virtual void        mouseDoubleClickEvent( QMouseEvent *pEvent );
  virtual void        mouseMoveEvent( QMouseEvent *pEvent );
  virtual void        wheelEvent( QWheelEvent *pEvent );
  virtual void        keyPressEvent( QKeyEvent *pEvent ); 
  virtual void        keyReleaseEvent( QKeyEvent *pEvent ); 
                      
  virtual void        timerEvent(QTimerEvent *pEvent);
  // end inherited protected methods from QWidget
  
  bool                _DoInertia();
  virtual void        _Inertia( int x, int y);
                      
  void                _DoRecordAndPlayback();
  
protected:     // Data
  Camera       _pCams[CAMERA_NUM_CAMS];          // array of 4 viewer cams
  Camera       *_pCam;                           // current cam ptr (default=0)
  Camera       _origCam;                         // orig. view for resetting
  bool         _pbCamDisplayOn[CAMERA_NUM_CAMS]; // display flag for each cam
  
  Vec3f        _worldCenter;                     // world bound-sphere center
  float        _rWorldRadius;                    // world bound-sphere radius
  Vec3f        _viewUp;                          // the world up-vector
  
  bool         _bInsideLookingOutMode;           // nav. mode (in->out/out->in)
  WorldNavMode _eWorldNavMode;                   // world navigation mode
  
  // Mouse State
  int          _iOldX, _iOldY, _iNewX, _iNewY;   // old and new mouse pos.
  float        _rMoveSpeed;
  ButtonState  _buttonState;
  
  bool         _bInertiaOn;
  bool         _bInertiaEnabled;
  int          _iInertiaDelay;
  int          _iInertiaTimerID;
  int          _iInertiaMinMove;
  
  // Path Recording and Playback
  char         *_pPathFilename;
  bool         _bRecordingOn;
  bool         _bPlaybackOn;
  FILE         *_pPathFP;
  
  struct timeb _lastFPSClock;
  bool         _bCalcFPS;
  float        _rLastFPS;
  int          _iLastFPSCount;
  int          _iFPSDelay;
  int          _iFPSTimerID;
  float        _rFPSIntegrateInterval; // minimum secs to integrate frame-rate.

  
protected:    // function pointers
  void        (*_pfInitializeGL)(QGLVUWidget*);
  void        (*_pfResizeGL)(QGLVUWidget*, int, int);
  void        (*_pfPaintGL)(QGLVUWidget*);
};

// BEGIN INLINE METHODS

inline void QGLVUWidget::SetCurrentCam(Camera *pNewCam)
{ 
  _pCam = pNewCam;                  
}     

inline Camera* QGLVUWidget::GetCurrentCam()                      
{ 
  return(_pCam);                    
}     

inline Camera* QGLVUWidget::GetCam(int whichCam)
{ 
  return(&_pCams[whichCam]);        
}
   
inline bool QGLVUWidget::GetInOutMode() const                 
{ 
  return _bInsideLookingOutMode;    
}

inline void QGLVUWidget::SetInOutMode(bool bMode)           
{ 
  _bInsideLookingOutMode = bMode;   
}

inline int QGLVUWidget::GetWorldNavMode() const              
{ 
  return _eWorldNavMode;            
}

inline const Vec3f& QGLVUWidget::GetViewUp() const                    
{ 
  return _viewUp;                   
}

inline const Vec3f& QGLVUWidget::GetWorldCenter() const               
{ 
  return _worldCenter;              
}

inline float QGLVUWidget::GetWorldRadius() const               
{ 
  return _rWorldRadius;             
}

inline void QGLVUWidget::SetViewUp(Vec3f viewup)
{ 
  _viewUp = viewup;
}
 
inline void QGLVUWidget::SetWorldCenter(const Vec3f& center) 
{ 
  _worldCenter = center;            
}

inline void QGLVUWidget::SetWorldRadius(float newRadius)
{ 
  _rWorldRadius = newRadius;
}
  
inline bool QGLVUWidget::GetCamDisplayOn(int whichCam) const  
{ 
  return _pbCamDisplayOn[whichCam]; 
}
  
inline bool QGLVUWidget::GetInertiaOn() const
{ 
  return _bInertiaOn;
} 
  
inline bool QGLVUWidget::GetInertiaEnabled() const
{ 
  return _bInertiaEnabled;
}

inline int QGLVUWidget::GetInertiaDelay() const
{ 
  return _iInertiaDelay;
} 

inline void QGLVUWidget::SetInertiaEnabled( bool bEnable)
{ 
  _bInertiaEnabled = bEnable;
}

inline void QGLVUWidget::SetInertiaDelay(int iMilliseconds)
{ 
  _iInertiaDelay = iMilliseconds;
}

inline int QGLVUWidget::GetInertiaMinMove() const
{ 
  return _iInertiaMinMove;
}

inline void QGLVUWidget::SetInertiaMinMove( int iAmount )
{ 
  _iInertiaMinMove = iAmount;
}

inline void QGLVUWidget::StartFPSClock()
{ 
  _bCalcFPS = 1; 
  ftime(&_lastFPSClock); 
  _iLastFPSCount=0;
}

inline void QGLVUWidget::StopFPSClock()  
{ 
  _bCalcFPS = 0; 
}

inline float QGLVUWidget::GetFPS() const
{ 
  return _rLastFPS; 
}

inline void QGLVUWidget::SetFPSIntegrateInterval(float rInterval)
{
  _rFPSIntegrateInterval = rInterval;
}

inline Qt::ButtonState QGLVUWidget::GetButtonState() const
{ 
  return _buttonState;
}

inline void QGLVUWidget::GetMousePos(int &ix, int &iy) const
{ 
  ix = _iOldX;
  iy = _iOldY;
}

inline void QGLVUWidget::SelectCam( int whichCam )
{ 
  _pCam = &_pCams[whichCam]; 
  repaint(); 
} 

inline int QGLVUWidget::SetWorldNavMode(WorldNavMode mode)
{ 
  return (_eWorldNavMode = mode);
}


  
#endif //__QGLVUWIDGET_H__

---