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