gripper_equipped_entity.h

Go to the documentation of this file.

#ifndef GRIPPER_EQUIPPED_ENTITY_H
#define GRIPPER_EQUIPPED_ENTITY_H

namespace argos {
   class CGripperEquippedEntity;
   class CEmbodiedEntity;
}

#include <argos3/core/simulator/entity/entity.h>
#include <argos3/core/utility/math/vector3.h>
#include <argos3/core/utility/math/quaternion.h>

namespace argos {

   class CGripperEquippedEntity : public CEntity {

   public:

      ENABLE_VTABLE();

   public:

      CGripperEquippedEntity(CComposableEntity* pc_parent);

      CGripperEquippedEntity(CComposableEntity* pc_parent,
                             const std::string& str_id,
                             const CVector3& c_offset,
                             const CVector3& c_direction,
                             Real f_lock_threshold = 0.5f);

      virtual void Init(TConfigurationNode& t_tree);

      virtual void Reset();

      inline const CVector3& GetOffset() const {
         return m_cOffset;
      }

      inline const CVector3& GetInitOffset() const {
         return m_cInitOffset;
      }

      inline void SetOffset(const CVector3& c_offset) {
         m_cOffset = c_offset;
      }

      inline void SetInitOffset(const CVector3& c_offset) {
         m_cInitOffset = c_offset;
      }

      inline const CVector3& GetDirection() const {
         return m_cDirection;
      }

      inline const CVector3& GetInitDirection() const {
         return m_cInitDirection;
      }

      inline void SetDirection(const CVector3& c_direction) {
         m_cDirection = c_direction;
      }

      inline void SetInitDirection(const CVector3& c_direction) {
         m_cInitDirection = c_direction;
      }

      inline Real GetLockState() const {
         return m_fLockState;
      }

      void SetLockState(Real f_lock_state);

      inline Real GetLockThreshold() const {
         return m_fLockThreshold;
      }

      void SetLockThreshold(Real f_lock_threshold);

      inline bool IsLocked() const {
         return m_fLockState > m_fLockThreshold;
      }

      inline bool IsGripping() const {
         return (m_pcGrippedEntity != NULL);
      }

      CEmbodiedEntity& GetGrippedEntity();

      inline void SetGrippedEntity(CEmbodiedEntity& c_entity) {
         m_pcGrippedEntity = &c_entity;
      }

      inline void ClearGrippedEntity() {
         m_pcGrippedEntity = NULL;
      }

      virtual std::string GetTypeDescription() const {
         return "gripper";
      }

   private:

      CVector3 m_cOffset;

      CVector3 m_cInitOffset;

      CVector3 m_cDirection;

      CVector3 m_cInitDirection;

      Real m_fLockState;

      Real m_fLockThreshold;

      CEmbodiedEntity* m_pcGrippedEntity;
      
   };
}

#endif