Entity.hh

/*
 * Copyright 2011 Nate Koenig & Andrew Howard
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
*/
/* Desc: Base class for all physical entities
 * Author: Nate Koenig
 * Date: 03 Apr 2007
 */

#ifndef ENTITY_HH
#define ENTITY_HH

#include <string>

#include "msgs/msgs.h"

#include "transport/TransportTypes.hh"
#include "common/CommonTypes.hh"
#include "math/MathTypes.hh"
#include "math/Box.hh"

#include "math/Pose.hh"
#include "physics/PhysicsTypes.hh"

#include "physics/Base.hh"

namespace boost
{
  class recursive_mutex;
}

namespace gazebo
{
    namespace physics
  {

    class Entity : public Base
    {
      public: Entity(BasePtr parent);
    
      public: virtual ~Entity();
  
      public: virtual void Load( sdf::ElementPtr &_sdf );

      public: virtual void Fini();

      public: virtual void Reset();

      public: virtual void UpdateParameters( sdf::ElementPtr &_sdf );

      public: virtual void SetName(const std::string &name);
   
      public: void SetStatic(const bool &s);
    
      public: bool IsStatic() const;

      public: void SetInitialRelativePose( const math::Pose &p );

      public: virtual math::Box GetBoundingBox() const;
  
      public: inline const math::Pose &GetWorldPose() const
              {return this->worldPose;}
  
      public: math::Pose GetRelativePose() const;
  
      public: void SetRelativePose(const math::Pose &pose, bool notify = true);
  
      public: void SetWorldPose(const math::Pose &pose, bool notify=true);

      public: virtual math::Vector3 GetRelativeLinearVel() const
              {return math::Vector3();}
  
      public: virtual math::Vector3 GetWorldLinearVel() const
              {return math::Vector3();}
  
      public: virtual math::Vector3 GetRelativeAngularVel() const
              {return math::Vector3();}
  
      public: virtual math::Vector3 GetWorldAngularVel() const
              {return math::Vector3();}
  
      public: virtual math::Vector3 GetRelativeLinearAccel() const
              {return math::Vector3();}
  
      public: virtual math::Vector3 GetWorldLinearAccel() const
              {return math::Vector3();}
  
  
      public: virtual math::Vector3 GetRelativeAngularAccel() const
              {return math::Vector3();}
  
      public: virtual math::Vector3 GetWorldAngularAccel() const
              {return math::Vector3();}

      public: void SetCanonicalLink(bool _value);

      public: inline bool IsCanonicalLink() const
              { return this->isCanonicalLink; }

      public: void SetAnimation(const common::PoseAnimationPtr &_anim,
                                boost::function<void()> _onComplete);
      public: void SetAnimation(const common::PoseAnimationPtr &_anim);

      private: void PublishPose();
 
      public: ModelPtr GetParentModel();

      public: CollisionPtr GetChildCollision(const std::string &_name);

      public: LinkPtr GetChildLink(const std::string &_name);

      public: void GetNearestEntityBelow(double &_distBelow,
                                         std::string &_entityName);

      public: void PlaceOnNearestEntityBelow();

      public: math::Box GetCollisionBoundingBox() const;

      public: void SetWorldTwist(const math::Vector3 &linear,
                                 const math::Vector3 &angular,
                                 bool updateChildren=true);

      public: const math::Pose &GetDirtyPose() const; 

      private: math::Box GetCollisionBoundingBoxHelper(BasePtr _base) const;

      private: void SetWorldPoseModel(const math::Pose &_pose, bool _notify);

      private: void SetWorldPoseCanonicalLink(const math::Pose &_pose,
                                              bool _notify);

      private: void SetWorldPoseDefault(const math::Pose &_pose, bool _notify);

      private: void OnPoseMsg(ConstPosePtr &_msg);

      protected: virtual void OnPoseChange() = 0;
  
      private: void UpdatePhysicsPose(bool update_children = true);

      private: void UpdateAnimation();
  
      protected: EntityPtr parentEntity;

      private: bool isStatic;

      private: bool isCanonicalLink;
  
      private: math::Pose initialRelativePose;
      private: math::Pose worldPose;

      protected: transport::NodePtr node;
      private: transport::PublisherPtr posePub;
      private: transport::SubscriberPtr poseSub;
      protected: transport::PublisherPtr visPub;
      protected: transport::PublisherPtr requestPub;

      protected: msgs::Visual *visualMsg;
      protected: msgs::Pose *poseMsg;

      protected: common::PoseAnimationPtr animation;
      protected: common::Time prevAnimationTime;
      protected: math::Pose animationStartPose;

      protected: std::vector<event::ConnectionPtr> connections;
      protected: event::ConnectionPtr animationConnection;

      protected: math::Pose dirtyPose;
      private: boost::function<void()> onAnimationComplete;

      private: void (Entity::*setWorldPoseFunc)(const math::Pose &, bool);
    };
    
  }
}
#endif