Entity.hh

Go to the documentation of this file.

/*
 * Copyright 2011 Nate Koenig
 *
 * 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 <vector>

#include "gazebo/msgs/msgs.hh"

#include "gazebo/transport/TransportTypes.hh"
#include "gazebo/common/CommonTypes.hh"

#include "gazebo/math/MathTypes.hh"
#include "gazebo/math/Box.hh"
#include "gazebo/math/Pose.hh"

#include "gazebo/physics/PhysicsTypes.hh"
#include "gazebo/physics/Base.hh"

namespace boost
{
  class recursive_mutex;
}

namespace gazebo
{
  namespace physics
  {

    class Entity : public Base
    {
      public: explicit 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 &_static);

      public: bool IsStatic() const;

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

      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,
                                   bool _publish = true);

      public: void SetWorldPose(const math::Pose &_pose,
                                bool _notify = true,
                                bool _publish = 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(common::PoseAnimationPtr _anim);

      public: virtual void StopAnimation();

      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: void PlaceOnEntity(const std::string &_entityName);

      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: void PublishPose();

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

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

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

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

      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, bool);
    };

  }
}
#endif