physics_model.h

Go to the documentation of this file.

 
#ifndef PHYSICS_MODEL_H
#define PHYSICS_MODEL_H
 
namespace argos {
   class CPhysicsModel;
   class CPhysicsEngine;
   class CRay3;
   class CQuaternion;
   class CEmbodiedEntity;
   struct SAnchor;
}
 
#include <argos3/core/utility/datatypes/datatypes.h>
#include <argos3/core/utility/math/vector3.h>
#include <argos3/core/utility/math/quaternion.h>
#include <map>
#include <vector>
#include <string>
 
namespace argos {
 
   /****************************************/
   /****************************************/
 
   struct SAnchor {
      CEmbodiedEntity& Body;
      std::string Id;
      UInt32 Index;
      CVector3 OffsetPosition;
      CQuaternion OffsetOrientation;
      CVector3 Position;
      CQuaternion Orientation;
      UInt32 InUseCount;
      SAnchor(CEmbodiedEntity& c_body,
              const std::string& str_id,
              UInt32 un_index,
              const CVector3& c_offset_position,
              const CQuaternion& c_offset_orientation,
              const CVector3& c_position,
              const CQuaternion& c_orientation);
      void Enable();
      void Disable();
   };
 
   /****************************************/
   /****************************************/
 
   struct SBoundingBox {
      CVector3 MinCorner;
      CVector3 MaxCorner;
 
      inline bool Intersects(const SBoundingBox& s_bb) const {
         return
            (MinCorner.GetX() < s_bb.MaxCorner.GetX()) && (MaxCorner.GetX() > s_bb.MinCorner.GetX()) &&
            (MinCorner.GetY() < s_bb.MaxCorner.GetY()) && (MaxCorner.GetY() > s_bb.MinCorner.GetY()) &&
            (MinCorner.GetZ() < s_bb.MaxCorner.GetZ()) && (MaxCorner.GetZ() > s_bb.MinCorner.GetZ());
      }
   };
 
   /****************************************/
   /****************************************/
 
   class CPhysicsModel {
 
   public:
 
      typedef std::map<std::string, CPhysicsModel*> TMap;
      typedef std::vector<CPhysicsModel*> TVector;
 
   public:
 
      CPhysicsModel(CPhysicsEngine& c_engine,
                    CEmbodiedEntity& c_entity);
 
      virtual ~CPhysicsModel() {
         while(!m_vecAnchorMethodHolders.empty()) {
            delete m_vecAnchorMethodHolders.back();
            m_vecAnchorMethodHolders.pop_back();
         }
      }
 
      inline CPhysicsEngine& GetEngine() {
         return m_cEngine;
      }
 
      inline CEmbodiedEntity& GetEmbodiedEntity() {
         return m_cEmbodiedEntity;
      }
 
      inline const CEmbodiedEntity& GetEmbodiedEntity() const {
         return m_cEmbodiedEntity;
      }
 
      virtual void UpdateEntityStatus();
 
      virtual void UpdateFromEntityStatus() = 0;
 
      virtual void UpdatePhysics() {}
 
      virtual void MoveTo(const CVector3& c_position,
                          const CQuaternion& c_orientation) = 0;
 
      inline const SBoundingBox& GetBoundingBox() const {
         return m_sBoundingBox;
      }
 
      virtual void CalculateBoundingBox() = 0;
 
      virtual void CalculateAnchors();
 
      virtual bool IsCollidingWithSomething() const = 0;
 
      inline SBoundingBox& GetBoundingBox() {
         return m_sBoundingBox;
      }
 
   private:
 
      CPhysicsEngine& m_cEngine;
      CEmbodiedEntity& m_cEmbodiedEntity;
      SBoundingBox m_sBoundingBox;
 
   private:
 
      typedef void (CPhysicsModel::*TThunk)(SAnchor&);
 
      class CAnchorMethodHolder {};
 
      template <typename MODEL> class CAnchorMethodHolderImpl : public CAnchorMethodHolder {
      public:
         typedef void (MODEL::*TMethod)(SAnchor&);
         TMethod Method;
         CAnchorMethodHolderImpl(TMethod t_method) : Method(t_method) {}
      };
 
   private:
 
      template <typename USER_IMPL>
      void Thunk(SAnchor& s_anchor);
 
   private:
 
      std::vector<CAnchorMethodHolder*> m_vecAnchorMethodHolders;
 
      std::vector<TThunk> m_vecThunks;
 
   public:
 
      template <typename MODEL>
      void RegisterAnchorMethod(const SAnchor& s_anchor,
                                void(MODEL::*pt_method)(SAnchor&));
 
   };
 
   /****************************************/
   /****************************************/
 
   template <typename MODEL>
   void CPhysicsModel::Thunk(SAnchor& s_anchor) {
      /*
       * When this method is called, the static type of 'this'
       * is CPhysicsModel. Since we want to call
       * method in MODEL (subclass of CPhysicsModel),
       * we need a cast. The cast is static because we trust
       * the user on not doing anything stupid.
       */
      MODEL& cImpl = static_cast<MODEL&>(*this);
      /* Cast the method holder to its effective type */
      CAnchorMethodHolderImpl<MODEL>& cMethodHolder = static_cast<CAnchorMethodHolderImpl<MODEL>&>(*m_vecAnchorMethodHolders[s_anchor.Index]);
      /* Call the user-defined method */
      (cImpl.*(cMethodHolder.Method))(s_anchor);
   }
 
   template <typename MODEL>
   void CPhysicsModel::RegisterAnchorMethod(const SAnchor& s_anchor,
                                            void(MODEL::*pt_method)(SAnchor&)) {
      /* Add the thunk to the VTable */
      m_vecThunks[s_anchor.Index] = &CPhysicsModel::Thunk<MODEL>;
      /* Add the method holder to the map */
      m_vecAnchorMethodHolders[s_anchor.Index] = new CAnchorMethodHolderImpl<MODEL>(pt_method);
   }
 
   /****************************************/
   /****************************************/
 
}
 
#endif