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 Grabbing;     // true when grabbing
         QString Directory; // output directory
         QString BaseName;  // frame file basename
         QString Format;    // output file format
         SInt32 Quality;    // output quality [0-100]

         SFrameGrabData() :
            Grabbing(false),
            Directory("."),
            BaseName("frame_"),
            Format("png"),
            Quality(-1) {}

         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_InvertMouse) {
        m_bInvertMouse = b_InvertMouse;
      }

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