DraWinGL.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_GL_H_
#define __DRA_WIN_GL_H_

#ifdef FOUND_GLUT_LIBS
 #include <GL/glut.h>
#endif

#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(){

   GLwidth  = createIntOption(string("GLwidth"),string("GL Windows width"),400);
   GLheight = createIntOption(string("GLheight"),string("GL Windows height"),400);
   GLfov    = createDecimalOption(string("GLfov"),string("GL Field of view"),45.0);
   GLaspratio = createDecimalOption(string("GLaspratio"),string("GL aspect ratio"),1.0);
   GLzNear   = createDecimalOption(string("GLzNear"),string("GLzNear"),0.05);
   GLzFar   = createDecimalOption(string("GLzFar"),string("GLzFar"),100.0);
   GLxEye   = createDecimalOption(string("GLxEye"),string("GLxEye"),0.0);
   GLyEye   = createDecimalOption(string("GLyEye"),string("GLyEye"),0.0);
   GLzEye   = createDecimalOption(string("GLzEye"),string("GLzEye"),2.0);
   GLxCenter  = createDecimalOption(string("GLxCenter"),string("GLxCenter"),0.0);
   GLyCenter  = createDecimalOption(string("GLyCenter"),string("GLyCenter"),0.0);
   GLzCenter  = createDecimalOption(string("GLzCenter"),string("GLzCenter"),0.0);
   GLxUp    = createDecimalOption(string("GLxUp"),string("GLxUp"),0.0);
   GLyUp    = createDecimalOption(string("GLyUp"),string("GLyUp"),1.0);
   GLzUp    = createDecimalOption(string("GLzUp"),string("GLzUp"),0.0);
   GLactive    = createBoolOption(string("GLactive"),string("GLactive"),true);
   GLmanual    = createBoolOption(string("GLmanual"),string("GLmanual"),false);
   GLincrementalBB = createBoolOption(string("GLincrementalBB"),string("GLincrementalBB"),false);
   GLdisplayMVM  = createBoolOption(string("GLdisplayMVM"),string("GLdisplayMVM"),false);
   GLdisplayInfo  = createBoolOption(string("GLdisplayInfo"),string("GLdisplayInfo"),false);
   GLdisplayGrid  = createBoolOption(string("GLdisplayGrid"),string("GLdisplayGrid"),false);
   GLdisplayAxes  = createBoolOption(string("GLdisplayAxes"),string("GLdisplayAxes"),false);
   
   updateValues();

  }

  string getObjectName() const {
   return "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 DraWin{
 private:
  static const ResourcePlate _plate= DW_GL_RES;
  void updateBB(DraWinObj* draWinObj);
  void setColor(Color c);
  void setPose2D(Pose p);
  void unsetPose2D();
  
  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;    

  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 GLdrawKhepera2D(DraWinObj* draWinObj);
  void GLdrawQuad3D(DraWinObj* draWinObj);
  void GLdrawPar3D(DraWinObj* draWinObj);
  void GLdrawHalfLine2D(DraWinObj* draWinObj);
  void GLdrawCovEllipse2D(DraWinObj* draWinObj);

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

  void updateModelViewMatrix();
  void drawText();
  void drawPar3D(double x0, double x1, double y0, double y1,double z0, double z1, double red=0, double green=0, double blue=0);
//   void resetBB(void);
//   ///
//   void printBB(void);
};

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


#endif