qtopengl_user_functions.h

Go to the documentation of this file.

#ifndef QTOPENGL_USER_FUNCTIONS_H
#define QTOPENGL_USER_FUNCTIONS_H

namespace argos {
   class CQTOpenGLUserFunctions;
   class CFloorEntity;
}

class QPainter;

#include <argos3/core/utility/configuration/base_configurable_resource.h>
#include <argos3/plugins/simulator/visualizations/qt-opengl/qtopengl_main_window.h>
#include <argos3/plugins/simulator/visualizations/qt-opengl/qtopengl_widget.h>
#include <argos3/core/utility/datatypes/color.h>
#include <argos3/core/utility/math/quaternion.h>

namespace argos {

   class CQTOpenGLUserFunctions : public CBaseConfigurableResource {

   public:

      CQTOpenGLUserFunctions();

      virtual ~CQTOpenGLUserFunctions();

      virtual void Init(TConfigurationNode& t_tree) {}
      virtual void Reset() {}
      virtual void Destroy() {}

      virtual void KeyPressed(QKeyEvent* pc_event);

      virtual void KeyReleased(QKeyEvent* pc_event);

      virtual void MouseKeyPressed(QMouseEvent* pc_event) {}

      virtual void MouseKeyReleased(QMouseEvent* pc_event) {}

      virtual void MouseMoved(QMouseEvent* pc_event) {}

      virtual void EntitySelected(CEntity& c_entity) {}

      virtual void EntityDeselected(CEntity& c_entity) {}

      CEntity* GetSelectedEntity();

      virtual void SelectEntity(CEntity& c_entity);

      virtual void DeselectEntity();

      virtual void Draw(CFloorEntity& c_entity) {}

      virtual void DrawInWorld() {}

      virtual void DrawOverlay(QPainter& c_painter) {}

      CQTOpenGLMainWindow& GetMainWindow();

      void SetMainWindow(CQTOpenGLMainWindow& c_main_win);

      CQTOpenGLWidget& GetQTOpenGLWidget();

      void SetColor(const CColor& c_color);

      void DrawPoint(const CVector3& c_position,
                     const CColor& c_color = CColor::RED,
                     Real f_diameter  = 5.0);

      void DrawTriangle(const CVector3& c_position,
                        const CQuaternion& c_orientation,
                        Real f_base,
                        Real f_height,
                        const CColor& c_color = CColor::RED,
                        const bool b_fill = true);

      void DrawPolygon(const CVector3& c_position,
                       const CQuaternion& c_orientation,
                       const std::vector<CVector2>& vec_points,
                       const CColor& c_color = CColor::RED,
                       const bool b_fill = true);

      void DrawCircle(const CVector3& c_position,
                      const CQuaternion& c_orientation,
                      Real f_radius,
                      const CColor& c_color = CColor::RED,
                      const bool b_fill = true,
                      GLuint un_vertices = 20);

      void DrawCylinder(const CVector3& c_position,
                        const CQuaternion& c_orientation,
                        Real f_radius,
                        Real f_height,
                        const CColor& c_color = CColor::RED,
                        GLuint un_vertices = 20);

      void DrawBox(const CVector3& c_position,
                   const CQuaternion& c_orientation,
                   const CVector3& c_size,
                   const CColor& c_color = CColor::RED);

      void DrawRay(const CRay3& c_ray,
                   const CColor& c_color = CColor::RED,
                   Real f_width = 1.0f);

      void DrawText(const CVector3& c_position,
                    const std::string& str_text,
                    const CColor& c_color = CColor::BLACK,
                    const QFont& c_font = QFont());

   protected:

      typedef void (CQTOpenGLUserFunctions::*TThunk)(CEntity&);

      template <typename USER_IMPL, typename ENTITY>
      void Thunk(CEntity& c_entity);

      class CFunctionHolder {};

      template <typename USER_IMPL, typename ENTITY> class CFunctionHolderImpl : public CFunctionHolder {
      public:
         typedef void (USER_IMPL::*TFunction)(ENTITY&);
         TFunction Function;
         CFunctionHolderImpl(TFunction t_function) : Function(t_function) {}
      };

      CVTable<CQTOpenGLUserFunctions, CEntity, TThunk> m_cThunks;

      std::vector<CFunctionHolder*> m_vecFunctionHolders;

   public:

      template <typename USER_IMPL, typename ENTITY>
      void RegisterUserFunction(void(USER_IMPL::*pt_function)(ENTITY&));

      virtual void Call(CEntity& c_entity);

   private:

      CQTOpenGLMainWindow* m_pcQTOpenGLMainWindow;

   };

   /****************************************/
   /****************************************/

   template <typename USER_IMPL, typename ENTITY>
   void CQTOpenGLUserFunctions::Thunk(CEntity& c_entity) {
      /*
       * When this method is called, the static type of 'this'
       * is CQTOpenGLUserFunctions. Since we want to call
       * method in USER_IMPL (subclass of CQTOpenGLUserFunctions),
       * we need a cast. The cast is static because we trust
       * the user on not doing anything stupid.
       * The variable cImpl can be static because the cast is necessary
       * only the first time this function is called.
       */
      static USER_IMPL& cImpl = static_cast<USER_IMPL&>(*this);
      /* Cast the argument to the right type */
      ENTITY& cEntity = static_cast<ENTITY&>(c_entity);
      /* Cast the function holder to its effective type */
      CFunctionHolderImpl<USER_IMPL,ENTITY>& cFunctionHolder = static_cast<CFunctionHolderImpl<USER_IMPL,ENTITY>&>(*m_vecFunctionHolders[GetTag<ENTITY,CEntity>()]);
      /* Call the user-defined method */
      (cImpl.*(cFunctionHolder.Function))(cEntity);
   }

   template <typename USER_IMPL, typename ENTITY>
   void CQTOpenGLUserFunctions::RegisterUserFunction(void(USER_IMPL::*pt_function)(ENTITY&)) {
      /* Add the thunk to the VTable */
      m_cThunks.Add<ENTITY>(&CQTOpenGLUserFunctions::Thunk<USER_IMPL,ENTITY>);
      /* Add the function holder to the vector, padding gaps with NULL pointers */
      size_t unIdx = GetTag<ENTITY,CEntity>();
      if(m_vecFunctionHolders.size() <= unIdx) {
         m_vecFunctionHolders.resize(unIdx+1, NULL);
      }
      m_vecFunctionHolders[unIdx] = new CFunctionHolderImpl<USER_IMPL,ENTITY>(pt_function);
   }

   /****************************************/
   /****************************************/

}

/* Definitions useful for dynamic linking of user functions */
#define REGISTER_QTOPENGL_USER_FUNCTIONS(CLASSNAME, LABEL)  \
   REGISTER_SYMBOL(CQTOpenGLUserFunctions,                  \
                   CLASSNAME,                               \
                   LABEL,                                   \
                   "undefined",                             \
                   "undefined",                             \
                   "undefined",                             \
                   "undefined",                             \
                   "undefined")

#endif