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) {}
 
      virtual void EntityMoved(CEntity& c_entity,
                               const CVector3& c_old_pos,
                               const CVector3& c_new_pos) {}
 
      virtual void EntityRotated(CEntity& c_entity,
                                 const CQuaternion& c_old_orientation,
                                 const CQuaternion& c_new_orientation) {}
 
      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