embodied_entity.h

Go to the documentation of this file.

 
#ifndef EMBODIED_ENTITY_H
#define EMBODIED_ENTITY_H
 
namespace argos {
   class CEmbodiedEntity;
}
 
#include <argos3/core/simulator/entity/entity.h>
#include <argos3/core/simulator/space/positional_indices/grid.h>
#include <argos3/core/simulator/space/positional_indices/space_hash.h>
#include <argos3/core/utility/datatypes/set.h>
#include <argos3/core/utility/math/ray3.h>
#include <argos3/core/utility/math/quaternion.h>
#include <argos3/core/simulator/physics_engine/physics_engine.h>
#include <argos3/core/simulator/physics_engine/physics_model.h>
#include <algorithm>
 
namespace argos {
 
   class CEmbodiedEntity : public CEntity {
 
   public:
 
      ENABLE_VTABLE();
 
   public:
 
      CEmbodiedEntity(CComposableEntity* pc_parent);
 
      CEmbodiedEntity(CComposableEntity* pc_parent,
                      const std::string& str_id,
                      const CVector3& c_position = CVector3(),
                      const CQuaternion& c_orientation = CQuaternion(),
                      bool b_movable = true);
 
      virtual ~CEmbodiedEntity();
 
      virtual void Init(TConfigurationNode& t_tree);
 
      virtual void Reset();
 
      inline bool IsMovable() const {
         return m_bMovable;
      }
 
      inline void SetMovable(bool b_movable) {
         m_bMovable = b_movable;
      }
 
      inline const SAnchor& GetOriginAnchor() const {
         return *m_psOriginAnchor;
      }
 
      inline SAnchor& GetOriginAnchor() {
         return *m_psOriginAnchor;
      }
 
      SAnchor& AddAnchor(const std::string& str_id,
                         const CVector3& c_rel_position = CVector3(),
                         const CQuaternion& c_rel_orientation = CQuaternion());
      
      void EnableAnchor(const std::string& str_id);
 
      void DisableAnchor(const std::string& str_id);
 
      const SAnchor& GetAnchor(const std::string& str_id) const;
 
      SAnchor& GetAnchor(const std::string& str_id);
 
      inline std::map<std::string, SAnchor*>& GetAnchors() {
         return m_mapAnchors;
      }
 
      inline std::vector<SAnchor*>& GetEnabledAnchors() {
         return m_vecEnabledAnchors;
      }
 
      bool IsAnchorEnabled(const std::string& str_id);
 
      const SBoundingBox& GetBoundingBox() const;
 
      UInt32 GetPhysicsModelsNum() const;
 
      virtual void AddPhysicsModel(const std::string& str_engine_id,
                                   CPhysicsModel& c_physics_model);
 
      void RemovePhysicsModel(const std::string& str_engine_id);
 
      const CPhysicsModel& GetPhysicsModel(size_t un_idx) const;
 
      CPhysicsModel& GetPhysicsModel(size_t un_idx);
 
      const CPhysicsModel& GetPhysicsModel(const std::string& str_engine_id) const;
 
      CPhysicsModel& GetPhysicsModel(const std::string& str_engine_id);
 
      virtual bool MoveTo(const CVector3& c_position,
                          const CQuaternion& c_orientation,
                          bool b_check_only = false,
                          bool b_ignore_collisions = false);
 
      virtual bool IsCollidingWithSomething() const;
 
      virtual std::string GetTypeDescription() const {
         return "body";
      }
 
      void CalculateBoundingBox();
      
   protected:
      
      bool m_bMovable;
      CPhysicsModel::TMap m_tPhysicsModelMap;
      CPhysicsModel::TVector m_tPhysicsModelVector;
      SBoundingBox* m_sBoundingBox;
      SAnchor* m_psOriginAnchor;
      std::map<std::string, SAnchor*> m_mapAnchors;
      std::vector<SAnchor*> m_vecEnabledAnchors;
      CVector3 m_cInitOriginPosition;
      CQuaternion m_cInitOriginOrientation;
 
   };
 
   extern bool operator==(const SAnchor* ps_anchor,
                          const std::string& str_id);
 
   /****************************************/
   /****************************************/
 
   typedef std::vector<CEmbodiedEntity*> TEmbodiedEntityVector;
   typedef std::map<std::string, CEmbodiedEntity*> TEmbodiedEntityMap;
   typedef CSet<CEmbodiedEntity*> TEmbodiedEntitySet;
 
   /****************************************/
   /****************************************/
 
   class CEmbodiedEntitySpaceHashUpdater : public CSpaceHashUpdater<CEmbodiedEntity> {
      
   public:
      
      virtual void operator()(CAbstractSpaceHash<CEmbodiedEntity>& c_space_hash,
                              CEmbodiedEntity& c_element);
 
   private:
 
      SInt32 m_nMinX, m_nMinY, m_nMinZ;
      SInt32 m_nMaxX, m_nMaxY, m_nMaxZ;
 
   };
   /****************************************/
   /****************************************/
 
   class CEmbodiedEntityGridUpdater : public CGrid<CEmbodiedEntity>::COperation {
 
   public:
 
      CEmbodiedEntityGridUpdater(CGrid<CEmbodiedEntity>& c_grid);
      virtual bool operator()(CEmbodiedEntity& c_entity);
 
   private:
 
      CGrid<CEmbodiedEntity>& m_cGrid;
      SInt32 m_nMinI, m_nMinJ, m_nMinK;
      SInt32 m_nMaxI, m_nMaxJ, m_nMaxK;
   };
 
   /****************************************/
   /****************************************/
 
}
 
#endif