DraWinQtGL.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// $Id$
//
// Copyright 2008, 2009, 2010, 2011, 2012  Antonio Franchi and Paolo Stegagno    
//
// This file is part of MIP.
//
// MIP is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// MIP 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with MIP. If not, see <http://www.gnu.org/licenses/>.
//
// Contact info: antonio.franchi@tuebingen.mpg.de stegagno@diag.uniroma1.it
//
// ----------------------------------------------------------------------------



#ifndef __DRA_WIN_QT_GL_H_
#define __DRA_WIN_QT_GL_H_

#include <QtOpenGL/QGLWidget>
#include <QSlider>
#include <QToolBar>

#include "DraWin.h"

#include <Option.h>

using namespace std;

namespace MipResources{
 /* @{ */

class DraWinGLOptions : public Options {
 public:
  
  IntOption* GLwidth;
  IntOption* GLheight;
  /*perspective params*/
  DecimalOption* GLfov;
  DecimalOption* GLaspratio;
  DecimalOption* GLzNear;
  DecimalOption* GLzFar;
  /*lookAt params*/
  DecimalOption* GLxEye;
  DecimalOption* GLyEye;
  DecimalOption* GLzEye;
  DecimalOption* GLxCenter;
  DecimalOption* GLyCenter;
  DecimalOption* GLzCenter;
  DecimalOption* GLxUp;
  DecimalOption* GLyUp;
  DecimalOption* GLzUp;
  /*bool params*/
  BoolOption* GLactive;
  BoolOption* GLmanual;
  BoolOption* GLincrementalBB;
  BoolOption* GLdisplayMVM;
  BoolOption* GLdisplayInfo;
  BoolOption* GLdisplayGrid;
  BoolOption* GLdisplayAxes;
  
  DraWinGLOptions();
};

class DraWinGLPerspective{
 public:
  Decimal fov;      
  Decimal aspratio; 
  Decimal zNear;    
  Decimal zFar;     
};

class DraWinGLLookAt{
 public:
  Decimal xEye;     
  Decimal yEye;     
  Decimal zEye;     
  Decimal xCenter;  
  Decimal yCenter;  
  Decimal zCenter;  
  Decimal xUp;      
  Decimal yUp;      
  Decimal zUp;   
};

class DraWinGLButtons{
 public:
  bool active;    
  bool manual;   
  bool incrementalBB;  
  bool displayMVM;  
  bool displayInfo; 
  bool displayGrid; 
  bool displayAxes; 
  DraWinGLButtons(){
   active = false;
   manual = false;
   incrementalBB = false;
   displayMVM = false;
   displayInfo = false;
   displayGrid = false;
   displayAxes = false;
  }
};

class DraWinGLVar{
 public:
  DraWinGLPerspective persp;  
  DraWinGLLookAt   lookAt;  
  DraWinGLButtons   buttons; 
  
  Decimal   MVM[16];         /* matrice omegenea della vista, aggiornata dal drawer */
  Decimal  actualFPS;       /*reale FPS*/
  unsigned int robotId;
  
  DraWinGLVar(){};
};

// enum LSRDraw_t{LSR_FILL, LSR_CONTOUR, LSR_CONTOUR_AND_FILL};

class DraWinGL: public QGLWidget, public DraWin{
 Q_OBJECT

 private:
  static const ResourcePlate _plate= DW_GL_RES;
  void updateBB(DraWinObj* draWinObj);
  void setColor(Color c);
  void setPose2D(Pose p);
  void unsetPose2D();
  
  void DrawAxes();
  
  void renderBitmapString(Decimal x, Decimal y, void *font, char *string);
  void setOrthographicProjection(int w, int h);
  void resetPerspectiveProjection();
  void drawModelViewMatrix();
  void drawInfo();
  
 public:
  DraWinGLOptions  options; 
  DraWinGLVar _var;      
  DraWinGLVar _defaultVar;  
  //Thread _GLThread;    ///< thread that manages the GLWindow

  DraWinGL(int argc, const char* argv[]);
  
  ~DraWinGL();
  
  ResourcePlate getPlate() const {
   return _plate;
  }

  void getDefaultVar();
  
  bool drawingCycle(Time timeout);
  
  void drawObject(DraWinObj* draWinObj);
  
  bool execCmd(DraWinObj* draWinObj);
  
  void GLdrawPoint2D(DraWinObj* draWinObj);
  
  void GLdrawPoints2D(DraWinObj* draWinObj);
  
  void GLdrawPolygon2D(DraWinObj* draWinObj);
  
  void GLdrawSeg2D(DraWinObj* draWinObj);
  
  void GLdrawDisk2D(DraWinObj* draWinObj);
  
  void GLdrawMobRob2D(DraWinObj* draWinObj);
  
  void GLdrawHalfLine2D(DraWinObj* draWinObj);

  void GLexecBB2D(DraWinObj* draWinObj);
    
  void manualModelView();
  
  void autoModelView();
  
  void zNearFarControl(void);

  void updateModelViewMatrix();
  
  void drawText();
  
  void defaultView(int width, int height);
  
//   void resetBB(void);
//   ///
//   void printBB(void);

  QSize minimumSizeHint() const;
  QSize sizeHint() const;

 public slots:
  void setXRotation(int angle);
  void setYRotation(int angle);
  void setZRotation(int angle);
      
  void increaseZ();
  void decreaseZ();
  void stopZ();
  void increaseY();
  void decreaseY();
  void stopY();
  void increaseX();
  void decreaseX();
  void stopX();
  void manual();
  void grid();
  
 signals:
   void xRotationChanged(int angle);
   void yRotationChanged(int angle);
   void zRotationChanged(int angle);

 protected:
  void initializeGL();
  void paintGL();
  void resizeGL(int width, int height);
  void mousePressEvent(QMouseEvent *event);
  void mouseMoveEvent(QMouseEvent *event);

 private:
  GLuint makeObject();
  void normalizeAngle(int *angle);

  GLuint object;
  int xRot;
  int yRot;
  int zRot;
  QPoint lastPos;
  QColor green;
  QColor white;
};


class DraWinGLWindow : public QWidget{
  Q_OBJECT

public:
  DraWinGLWindow(DraWinGL *dGL);
  
  void fillToolBar(QToolBar *);
  
  QSize sizeHint() const;
private:
  QSlider *createSlider();
  QWidget *createButtons();

  DraWinGL *glWidget;
  QSlider *xSlider;
  QSlider *ySlider;
  QSlider *zSlider;
  
  QWidget *buttons;
};


 /* @} */
 
};// end namespace MipResources{


#endif