physics_engine.h

Go to the documentation of this file.

 
#ifndef PHYSICS_ENGINE_H
#define PHYSICS_ENGINE_H
 
namespace argos {
   class CPhysicsEngine;
   class CPhysicsModel;
   class CEntity;
   class CEmbodiedEntity;
   class CVector3;
   class CRay3;
}
 
#include <map>
#include <argos3/core/utility/logging/argos_log.h>
#include <argos3/core/utility/math/ray2.h>
#include <argos3/core/utility/configuration/base_configurable_resource.h>
#include <argos3/core/utility/configuration/argos_configuration.h>
#include <argos3/core/utility/datatypes/datatypes.h>
#include <argos3/core/utility/plugins/factory.h>
 
namespace argos {
 
   /****************************************/
   /****************************************/
 
   struct SEmbodiedEntityIntersectionItem {
      CEmbodiedEntity* IntersectedEntity;
      Real TOnRay;
 
      SEmbodiedEntityIntersectionItem() :
         IntersectedEntity(NULL),
         TOnRay(1.0f) {}
 
      SEmbodiedEntityIntersectionItem(CEmbodiedEntity* pc_entity,
                                      Real f_t_on_ray) :
         IntersectedEntity(pc_entity),
         TOnRay(f_t_on_ray) {}
 
      SEmbodiedEntityIntersectionItem(const SEmbodiedEntityIntersectionItem& s_item) :
         IntersectedEntity(s_item.IntersectedEntity),
         TOnRay(s_item.TOnRay) {}
      SEmbodiedEntityIntersectionItem& operator=(const SEmbodiedEntityIntersectionItem& s_item) {
         IntersectedEntity = s_item.IntersectedEntity;
         TOnRay = s_item.TOnRay;
         return *this;
      }
      inline bool operator<(const SEmbodiedEntityIntersectionItem& s_item) {
         return TOnRay < s_item.TOnRay;
      }
   };
 
   typedef std::vector<SEmbodiedEntityIntersectionItem> TEmbodiedEntityIntersectionData;
 
   extern bool GetEmbodiedEntitiesIntersectedByRay(TEmbodiedEntityIntersectionData& t_data,
                                                   const CRay3& c_ray);
 
   extern bool GetClosestEmbodiedEntityIntersectedByRay(SEmbodiedEntityIntersectionItem& s_item,
                                                        const CRay3& c_ray);
 
   extern bool GetClosestEmbodiedEntityIntersectedByRay(SEmbodiedEntityIntersectionItem& s_item,
                                                        const CRay3& c_ray,
                                                        CEmbodiedEntity& c_entity);
 
   /****************************************/
   /****************************************/
 
   class CPhysicsEngine : public CBaseConfigurableResource {
 
   public:
 
      struct SBoundaryFace {
         std::string EngineId;
      };
 
      struct SHorizontalFace : public SBoundaryFace {
         Real Height;
      };
 
      struct SVerticalFace : public SBoundaryFace {
         CRay2 BaseSegment;
      };
 
      struct SVolume {
         SHorizontalFace*            TopFace;
         SHorizontalFace*            BottomFace;
         std::vector<SVerticalFace*> SideFaces;
         SVolume();
         ~SVolume();
         void Init(TConfigurationNode& t_node);
         bool IsActive() const;
      };
      
   public:
 
      typedef std::vector<CPhysicsEngine*> TVector;
      typedef std::map<std::string, CPhysicsEngine*, std::less<std::string> > TMap;
 
   public:
 
      CPhysicsEngine();
      virtual ~CPhysicsEngine() {}
 
      virtual void Init(TConfigurationNode& t_tree);
      virtual void Reset() {}
      virtual void Destroy() {}
 
      virtual void Update() = 0;
 
      virtual void PostSpaceInit() {}
 
      virtual bool IsPointContained(const CVector3& c_point);
 
      virtual size_t GetNumPhysicsModels() = 0;
 
      virtual bool AddEntity(CEntity& c_entity) = 0;
 
      virtual bool RemoveEntity(CEntity& c_entity) = 0;
 
      inline bool IsEntityTransferNeeded() const {
         return !m_vecTransferData.empty();
      }
 
      inline bool IsEntityTransferActive() const {
         return m_sVolume.IsActive();
      }
 
      virtual void ScheduleEntityForTransfer(CEmbodiedEntity& c_entity);
 
      virtual void TransferEntities();
 
      inline SVolume& GetVolume() {
         return m_sVolume;
      }
 
      inline const SVolume& GetVolume() const {
         return m_sVolume;
      }
 
      virtual void CheckIntersectionWithRay(TEmbodiedEntityIntersectionData& t_data,
                                            const CRay3& c_ray) const = 0;
 
      static Real GetSimulationClockTick();
 
      static Real GetInverseSimulationClockTick();
 
      static void SetSimulationClockTick(Real f_simulation_clock_tick);
 
      inline UInt32 GetIterations() const {
         return m_unIterations;
      }
 
      inline Real GetPhysicsClockTick() const {
         return m_fPhysicsClockTick;
      }
 
      inline const std::string& GetId() const {
         return m_strId;
      }
 
      void SetId(const std::string& str_id) {
         m_strId = str_id;
      }
               
   private:
 
      UInt32 m_unIterations;
 
      Real m_fPhysicsClockTick;
 
      std::string m_strId;
 
      static Real m_fSimulationClockTick;
 
      static Real m_fInverseSimulationClockTick;
 
      SVolume m_sVolume;
 
      std::vector<CEmbodiedEntity*> m_vecTransferData;
   };
 
}
 
#define REGISTER_PHYSICS_ENGINE(CLASSNAME,          \
                                LABEL,              \
                                AUTHOR,             \
                                VERSION,            \
                                BRIEF_DESCRIPTION,  \
                                LONG_DESCRIPTION,   \
                                STATUS)             \
   REGISTER_SYMBOL(CPhysicsEngine,                  \
                   CLASSNAME,                       \
                   LABEL,                           \
                   AUTHOR,                          \
                   VERSION,                         \
                   BRIEF_DESCRIPTION,               \
                   LONG_DESCRIPTION,                \
                   STATUS)
 
#endif