qtopengl_widget.h

Go to the documentation of this file.

 
#ifndef QTOPENGL_WIDGET_H
#define QTOPENGL_WIDGET_H
 
namespace argos {
   class CQTOpenGLWidget;
   class CQTOpenGLMainWindow;
   class CSpace;
   class CSimulator;
   class CQTOpenGLBox;
   class CQTOpenGLUserFunctions;
   class CPositionalEntity;
   class CControllableEntity;
   class CEmbodiedEntity;
}
 
#include <argos3/plugins/simulator/visualizations/qt-opengl/qtopengl_camera.h>
#include <argos3/core/simulator/entity/entity.h>
#include <argos3/core/utility/datatypes/datatypes.h>
#include <QOpenGLWidget>
#include <QOpenGLFunctions>
#include <QOpenGLTexture>
 
#ifdef __APPLE__
#include <glu.h>
#else
#include <GL/glu.h>
#endif
 
namespace argos {
 
   /****************************************/
   /****************************************/
 
   class CQTOpenGLOperationDrawNormal : public CEntityOperation<CQTOpenGLOperationDrawNormal, CQTOpenGLWidget, void> {
   public:
      virtual ~CQTOpenGLOperationDrawNormal() {}
   };
 
   class CQTOpenGLOperationDrawSelected : public CEntityOperation<CQTOpenGLOperationDrawSelected, CQTOpenGLWidget, void> {
   public:
      virtual ~CQTOpenGLOperationDrawSelected() {}
   };
 
#define REGISTER_QTOPENGL_ENTITY_OPERATION(ACTION, OPERATION, ENTITY)   \
   REGISTER_ENTITY_OPERATION(ACTION, CQTOpenGLWidget, OPERATION, void, ENTITY);
 
   /****************************************/
   /****************************************/
 
   class CQTOpenGLWidget : public QOpenGLWidget, protected QOpenGLFunctions {
 
    Q_OBJECT
 
    public:
 
      struct SFrameGrabData {
         bool GUIGrabbing;          // true when grabbing enabled from GUI
         bool HeadlessGrabbing;     // true when headless grabbing enabled
         UInt32 HeadlessFrameRate;  // Grab every nth frame
         QString Directory;         // output directory
         QString BaseName;          // frame file basename
         QString Format;            // output file format
         SInt32 Quality;            // output quality [0-100]
         QSize  Size;               // Frame size
 
         SFrameGrabData() :
            GUIGrabbing(false),
            HeadlessGrabbing(false),
            HeadlessFrameRate(1),
            Directory("."),
            BaseName("frame_"),
            Format("png"),
            Quality(-1),
            Size(1600, 1200) {}
 
         void Init(TConfigurationNode& t_tree);
      };
 
      struct SSelectionInfo {
         bool IsSelected;         // true when an entity is selected
         CEntity* Entity;         // the selected entity
 
         SSelectionInfo() :
            IsSelected(false),
            Entity(NULL) {}
      };
 
   public:
 
      CQTOpenGLWidget(QWidget* pc_parent,
                      CQTOpenGLMainWindow& c_main_window,
                      CQTOpenGLUserFunctions& c_user_functions);
      virtual ~CQTOpenGLWidget();
 
      virtual void initializeGL();
 
      virtual void paintGL();
 
      CRay3 RayFromWindowCoord(int n_x,
                               int n_y);
 
      CVector3 GetWindowCoordInWorld(int n_x,
                                     int n_y);
 
      CEntity* GetSelectedEntity();
 
      void SelectEntity(CEntity& c_entity);
 
      void DeselectEntity();
 
      void SelectInScene(UInt32 un_x,
                         UInt32 un_y);
 
      void DrawEntity(CPositionalEntity& c_entity);
 
      void DrawEntity(CEmbodiedEntity& c_entity);
 
      void DrawRays(CControllableEntity& c_entity);
 
      void DrawBoundingBox(CEmbodiedEntity& c_entity);
 
      inline virtual int heightForWidth(int w) const {
         return (w * 3) / 4;
      }
 
      inline virtual QSize sizeHint() const {
         return QSize(1024,768);
      }
 
      inline virtual QSize minimumSize() const {
         return QSize(320,240);
      }
 
      inline CQTOpenGLUserFunctions& GetUserFunctions() {
         return m_cUserFunctions;
      }
 
      inline CQTOpenGLCamera& GetCamera() {
         return m_cCamera;
      }
 
      inline SFrameGrabData& GetFrameGrabData() {
         return m_sFrameGrabData;
      }
 
      inline void SetInvertMouse(bool b_invert_mouse) {
         m_bInvertMouse = b_invert_mouse;
      }
 
      inline void SetShowBoundary(bool b_show_boundary) {
         m_bShowBoundary = b_show_boundary;
      }
 
   signals:
 
      void StepDone(int n_step);
 
      void ExperimentDone();
 
      void EntitySelected(CEntity* pc_entity);
 
      void EntityDeselected(CEntity* pc_entity);
 
   public slots:
 
      void PlayExperiment();
 
      void FastForwardExperiment();
 
      void PauseExperiment();
 
      void StepExperiment();
 
      void ResetExperiment();
 
      void SetDrawFrameEvery(int n_every);
 
      void SetGrabFrame(bool b_grab_on);
 
      void SetCamera(int n_camera);
 
      void SetCameraFocalLength(double f_length);
 
      void KeyPressed(QKeyEvent* pc_event);
 
      void KeyReleased(QKeyEvent* pc_event);
 
   protected:
 
      void DrawScene();
      void DrawArena();
      void DrawAxes();
 
      virtual void timerEvent(QTimerEvent* pc_event);
      virtual void mousePressEvent(QMouseEvent* pc_event);
      virtual void mouseReleaseEvent(QMouseEvent* pc_event);
      virtual void mouseMoveEvent(QMouseEvent* pc_event);
      virtual void wheelEvent(QWheelEvent *pc_event);
      virtual void keyPressEvent(QKeyEvent* pc_event);
      virtual void keyReleaseEvent(QKeyEvent* pc_event);
      virtual void resizeEvent(QResizeEvent* pc_event);
      void reactToKeyEvent();
 
   private:
 
      CQTOpenGLMainWindow& m_cMainWindow;
      CQTOpenGLUserFunctions& m_cUserFunctions;
 
      SInt32 nTimerId;
      bool m_bFastForwarding;
      SInt32 m_nDrawFrameEvery;
      SInt32 m_nFrameCounter;
 
      bool m_bMouseGrabbed;
      bool m_bShiftPressed;
      QPoint m_cMouseGrabPos;
      bool m_bInvertMouse;
      SSelectionInfo m_sSelectionInfo;
 
      CSimulator& m_cSimulator;
      CSpace& m_cSpace;
 
      bool m_bShowBoundary;
 
      bool m_bUsingFloorTexture;
      QOpenGLTexture* m_pcFloorTexture;
      QOpenGLTexture* m_pcGroundTexture;
 
      GLfloat* m_pfLightAmbient;
      GLfloat* m_pfLightDiffuse;
      GLfloat* m_pfLight0Position;
      GLfloat* m_pfLight1Position;
 
      //GLuint m_unArenaList;
      //GLuint m_unFloorList;
 
      CQTOpenGLCamera m_cCamera;
      SFrameGrabData m_sFrameGrabData;
 
      enum EDirection {
         DIRECTION_UP = 1,
         DIRECTION_DOWN,
         DIRECTION_LEFT,
         DIRECTION_RIGHT,
         DIRECTION_FORWARDS,
         DIRECTION_BACKWARDS,
      };
 
      QMap<EDirection, int> m_mapPressedKeys;
   };
 
}
 
#endif